chz-telegram-bot 0.5.4 → 0.6.8

package/types/events.ts

@@ -0,0 +1,285 @@
+import { ChatInfo } from '../dtos/chatInfo';
+import { IncomingMessage } from '../dtos/incomingMessage';
+import { IncomingInlineQuery } from '../dtos/incomingQuery';
+import { CommandAction } from '../entities/actions/commandAction';
+import { ChatContext } from '../entities/context/chatContext';
+import { InlineQueryContext } from '../entities/context/inlineQueryContext';
+import { MessageContext } from '../entities/context/messageContext';
+import { ReplyContext } from '../entities/context/replyContext';
+import { ActionKey, IAction, IActionWithState } from './action';
+import { IActionState } from './actionState';
+import { BotInfo } from './externalAliases';
+import { BotResponse } from './response';
+import { Milliseconds } from './timeValues';
+
+export const BotEventType = {
+    error: 'error.generic',
+
+    messageRecieved: 'message.recieved',
+    messageProcessingStarted: 'message.processingStarted',
+    messageProcessingFinished: 'message.processingFinished',
+    beforeActionsExecuting: 'message.beforeActionsExecuting',
+
+    commandActionExecuting: 'command.actionExecuting',
+    commandActionExecuted: 'command.actionExecuted',
+    commandActionCaptureStarted: 'command.captionStarted',
+    commandActionCaptureAborted: 'command.captionAborted',
+
+    replyActionExecuting: 'reply.actionExecuting',
+    replyActionExecuted: 'reply.actionExecuted',
+
+    inlineActionExecuting: 'inline.actionExecuting',
+    inlineActionExecuted: 'inline.actionExecuted',
+    inlineProcessingStarted: 'inline.processingStarted',
+    inlineProcessingAborting: 'inline.processingAborting',
+    inlineProcessingAborted: 'inline.processingAborted',
+
+    scheduledActionExecuting: 'scheduled.actionExecuting',
+    scheduledActionExecuted: 'scheduled.actionExecuted',
+    scheduledActionCacheValueReturned: 'scheduled.cachedValueReturned',
+    scheduledActionCacheValueCreating: 'scheduled.cachedValueCreating',
+
+    apiRequestSending: 'api.requestSending',
+    apiRequestSent: 'api.requestSent',
+
+    storageLockAcquiring: 'storage.lockAcquiring',
+    storageLockAcquired: 'storage.lockAcquired',
+    storageLockReleased: 'storage.lockReleased',
+    storageStateSaving: 'storage.stateSaving',
+    storageStateSaved: 'storage.stateSaved',
+    storageStateLoading: 'storage.stateLoading',
+    storageStateLoaded: 'storage.stateLoaded',
+
+    taskCreated: 'task.created',
+    taskRun: 'task.run',
+
+    botStarting: 'bot.starting',
+    botStopping: 'bot.stopping'
+} as const;
+
+type BotEventTypeKeys = (typeof BotEventType)[keyof typeof BotEventType];
+// Exhaustiveness validation
+const _checkBotEventMapExhaustive: Record<BotEventTypeKeys, unknown> =
+    null as unknown as BotEventMap;
+
+export type BotEventMap = {
+    [BotEventType.error]: {
+        error: Error;
+    };
+
+    [BotEventType.messageRecieved]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.messageProcessingStarted]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.messageProcessingFinished]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.beforeActionsExecuting]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+        commands: Set<CommandAction<IActionState>>;
+    };
+
+    [BotEventType.commandActionExecuting]: {
+        action: IActionWithState<IActionState>;
+        ctx: MessageContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.commandActionExecuted]: {
+        action: IActionWithState<IActionState>;
+        ctx: MessageContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.commandActionCaptureStarted]: {
+        parentMessageId: number;
+        chatInfo: ChatInfo;
+    };
+
+    [BotEventType.commandActionCaptureAborted]: {
+        parentMessageId: number;
+        chatInfo: ChatInfo;
+    };
+
+    [BotEventType.replyActionExecuting]: {
+        action: IAction;
+        ctx: ReplyContext<IActionState>;
+    };
+
+    [BotEventType.replyActionExecuted]: {
+        action: IAction;
+        ctx: ReplyContext<IActionState>;
+    };
+
+    [BotEventType.inlineActionExecuting]: {
+        action: IAction;
+        ctx: InlineQueryContext;
+    };
+
+    [BotEventType.inlineActionExecuted]: {
+        action: IAction;
+        ctx: InlineQueryContext;
+    };
+
+    [BotEventType.inlineProcessingStarted]: {
+        query: IncomingInlineQuery;
+    };
+
+    [BotEventType.inlineProcessingAborting]: {
+        abortedQuery: IncomingInlineQuery;
+        newQuery: IncomingInlineQuery;
+    };
+
+    [BotEventType.inlineProcessingAborted]: {
+        abortedQuery: IncomingInlineQuery;
+    };
+
+    [BotEventType.scheduledActionExecuting]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.scheduledActionExecuted]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.scheduledActionCacheValueCreating]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        key: string;
+    };
+
+    [BotEventType.scheduledActionCacheValueReturned]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        key: string;
+    };
+
+    [BotEventType.apiRequestSending]: {
+        response: BotResponse | null;
+        telegramMethod: string | null;
+    };
+
+    [BotEventType.apiRequestSent]: {
+        response: BotResponse | null;
+        telegramMethod: string | null;
+    };
+
+    [BotEventType.storageLockAcquiring]: ActionKey;
+    [BotEventType.storageLockAcquired]: ActionKey;
+    [BotEventType.storageLockReleased]: ActionKey;
+    [BotEventType.storageStateSaved]: {
+        key: ActionKey;
+        data: Record<number, unknown>;
+    };
+    [BotEventType.storageStateSaving]: {
+        key: ActionKey;
+        data: Record<number, unknown>;
+    };
+    [BotEventType.storageStateLoading]: {
+        action: IActionWithState<IActionState>;
+        chatId: number;
+    };
+    [BotEventType.storageStateLoaded]: {
+        action: IActionWithState<IActionState>;
+        chatId: number;
+        state: IActionState;
+    };
+
+    [BotEventType.taskCreated]: {
+        name: string;
+        ownerName: string;
+        delay?: Milliseconds;
+        interval?: Milliseconds;
+    };
+    [BotEventType.taskRun]: {
+        name: string;
+        ownerName: string;
+        delay?: Milliseconds;
+        interval?: Milliseconds;
+    };
+
+    [BotEventType.botStarting]: {
+        botName: string;
+    };
+
+    [BotEventType.botStopping]: {
+        botName: string;
+    };
+};
+
+type ListenerArgs<K extends keyof BotEventMap> =
+    BotEventMap[K] extends undefined ? [] : [BotEventMap[K]];
+
+export type Listener<K extends keyof BotEventMap> = (
+    timestamp: number,
+    ...args: ListenerArgs<K>
+) => void;
+
+export type EachListener = (
+    event: BotEventTypeKeys,
+    timestamp: number,
+    data: unknown
+) => void;
+
+export class TypedEventEmitter {
+    private readonly listeners = new Map<
+        keyof BotEventMap | '*',
+        Set<Listener<keyof BotEventMap> | EachListener>
+    >();
+
+    on<K extends keyof BotEventMap>(event: K, fn: Listener<K>) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn as Listener<keyof BotEventMap>);
+        this.listeners.set(event, set);
+    }
+
+    onEach(fn: EachListener) {
+        const event = '*';
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn);
+        this.listeners.set(event, set);
+    }
+
+    emit<K extends keyof BotEventMap>(
+        event: K,
+        ...args: ListenerArgs<K>
+    ): void {
+        const timestamp = Date.now();
+        const specific = this.listeners.get(event);
+        if (specific) {
+            for (const fn of specific) {
+                (fn as Listener<K>)(timestamp, ...args);
+            }
+        }
+
+        const anySet = this.listeners.get('*');
+        if (anySet) {
+            for (const fn of anySet) {
+                (
+                    fn as unknown as (
+                        e: K,
+                        t: number,
+                        ...a: ListenerArgs<K>
+                    ) => void
+                )(event, timestamp, ...args);
+            }
+        }
+    }
+
+    events(): (keyof BotEventMap | '*')[] {
+        return [...this.listeners.keys()];
+    }
+}

package/services/jsonLogger.ts

@@ -1,112 +0,0 @@
-import { ILogger, IScopedLogger } from '../types/logger';
-import { TraceId } from '../types/trace';
-
-export class JsonLogger implements ILogger {
-    private serializeError(error: unknown): string {
-        if (error instanceof Error) {
-            const plainObject: Record<string, unknown> = {
-                name: error.name,
-                message: error.message,
-                stack: error.stack
-            };
-
-            for (const [key, value] of Object.entries(error)) {
-                plainObject[key] = value;
-            }
-
-            return JSON.stringify(plainObject);
-        }
-
-        return JSON.stringify({ error });
-    }
-
-    private getCircularReplacer() {
-        const cache = new Set();
-        return <T>(_: string, value: T) => {
-            if (typeof value === 'object' && value !== null) {
-                if (cache.has(value)) {
-                    return;
-                }
-
-                cache.add(value);
-            }
-            return value;
-        };
-    }
-
-    createScope(botName: string, traceId: TraceId, chatName: string) {
-        return {
-            logObjectWithTraceId: (data: unknown) => {
-                this.logObjectWithTraceId(botName, traceId, chatName, data);
-            },
-            logWithTraceId: (text: string) => {
-                this.logWithTraceId(botName, traceId, chatName, text);
-            },
-            errorWithTraceId: (errorObj: unknown, extraData?: unknown) => {
-                this.errorWithTraceId(
-                    botName,
-                    traceId,
-                    chatName,
-                    errorObj,
-                    extraData
-                );
-            }
-        } as IScopedLogger;
-    }
-
-    logObjectWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        data: unknown
-    ) {
-        const enrichedData =
-            typeof data == 'object'
-                ? {
-                      ...data,
-                      botName,
-                      traceId,
-                      chatName
-                  }
-                : {
-                      botName,
-                      traceId,
-                      chatName,
-                      data
-                  };
-
-        console.log(enrichedData);
-    }
-
-    logWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        text: string
-    ) {
-        console.log(
-            `{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","text":"${text}"}`
-        );
-    }
-
-    errorWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        errorObj: unknown,
-        extraData?: unknown
-    ) {
-        const dataString = extraData
-            ? `,"extraData":${JSON.stringify(
-                  extraData,
-                  this.getCircularReplacer()
-              )}`
-            : '';
-
-        console.error(
-            `{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","error":${this.serializeError(
-                errorObj
-            )}${dataString}}`
-        );
-    }
-}

package/types/logger.ts

@@ -1,39 +0,0 @@
-import { TraceId } from './trace';
-
-export interface IScopedLogger {
-    logObjectWithTraceId(data: unknown): void;
-
-    logWithTraceId(text: string): void;
-
-    errorWithTraceId(errorObj: unknown, extraData?: unknown): void;
-}
-
-export interface ILogger {
-    createScope(
-        botName: string,
-        traceId: TraceId,
-        chatName: string
-    ): IScopedLogger;
-
-    logObjectWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        data: unknown
-    ): void;
-
-    logWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        text: string
-    ): void;
-
-    errorWithTraceId(
-        botName: string,
-        traceId: TraceId,
-        chatName: string,
-        errorObj: unknown,
-        extraData?: unknown
-    ): void;
-}