@andrey4emk/npm-app-back-b24 3.7.1 → 3.8.1

package/bitrix24/eventB24.ts

@@ -3,7 +3,18 @@ import { $b24, getResultData, type B24MethodCaller } from "./b24.ts";
 // ==================== Типы ====================
 
 /** Сообщение из коннектора */
-interface ConnectorMessage {
+export interface ConnectorMessage {
+    /**
+     * `MESSAGE_ID` записи очереди офлайн-событий — ключ для `clear()`.
+     * Идентифицирует запись, а не отдельное сообщение: у сообщений одной записи
+     * он общий, поэтому для дедупликации сообщений не годится (для этого `im.id`)
+     */
+    messageId: string;
+    /**
+     * `ID` записи очереди офлайн-событий. Поле информационное, для сверки
+     * с `event.offline.list`. В `clear()` не передавать — метод принимает `MESSAGE_ID`
+     */
+    eventId: string;
     connectorId: string;
     lineId: string;
     chatId: string;
@@ -14,7 +25,7 @@ interface ConnectorMessage {
 }
 
 /** События коннектора */
-interface ConnectorEvents {
+export interface ConnectorEvents {
     processId: string | null;
     message: ConnectorMessage[];
 }
@@ -26,7 +37,7 @@ interface MessageEntityLink {
 }
 
 /** События сущностей (сделки, смарт-процессы) */
-interface EntityEvents {
+export interface EntityEvents {
     processId: string | null;
     entitysId: string[];
     arrMessageIdAndEntityId: MessageEntityLink[];
@@ -41,6 +52,7 @@ interface StandardResult {
 
 /** Офлайн-событие Bitrix24 */
 interface OfflineEvent {
+    ID: string;
     MESSAGE_ID: string;
     EVENT_NAME: string;
     EVENT_DATA: any;
@@ -148,7 +160,19 @@ export class Event {
     }
 
     /**
-     * Получает офлайн-события по имени
+     * Получает офлайн-события по имени.
+     *
+     * Гранулярность очистки — запись очереди, а не сообщение. Для коннектора одна
+     * запись (один `MESSAGE_ID`) может нести несколько сообщений, и `get()` раскладывает
+     * их через `flatMap` — у таких сообщений `messageId` совпадает. Очистка по этому
+     * ключу удалит запись целиком: если из двух сообщений одной записи ушло одно,
+     * `clear()` заберёт и неотправленное. Поэлементную очистку с точностью до
+     * сообщения на этом ключе построить нельзя.
+     *
+     * Обратная сторона: запись, из которой не разобрано ни одного сообщения
+     * (пустой или битый `MESSAGES`), в `data.message` не попадает вовсе — очистка
+     * по собранным `messageId` её не заберёт, и она останется зарезервированной
+     * под тем же `process_id`. Безопасный режим — `clear(processId)` целиком.
      */
     async get(eventName: string): Promise<StandardResult> {
         try {
@@ -184,6 +208,10 @@ export class Event {
                         return normalizeMessages(eventData.MESSAGES)
                             .filter((messageData) => messageData?.chat && messageData?.message)
                             .map((messageData) => ({
+                                // Портал отдаёт идентификаторы то строкой, то числом —
+                                // приводим, чтобы тип `string` не врал
+                                messageId: String(event.MESSAGE_ID ?? ""),
+                                eventId: String(event.ID ?? ""),
                                 connectorId: eventData.CONNECTOR,
                                 lineId: eventData.LINE,
                                 chatId: messageData.chat.id,
@@ -210,6 +238,9 @@ export class Event {
 
             if (arrEventsToClear.length > 0) {
                 const arrMessageIdToClear = arrEventsToClear.map((event) => event.MESSAGE_ID);
+                // Результат намеренно не проверяется: отказ здесь не фатален — те же
+                // записи придут следующим опросом, а бросок лишил бы потребителя всей
+                // выборки активных событий
                 await this.b24.callMethod("event.offline.clear", {
                     process_id: arrOfflineEvents.process_id,
                     message_id: arrMessageIdToClear,
@@ -243,11 +274,29 @@ export class Event {
      */
     async clear(processId: string, messageId?: string | string[]): Promise<StandardResult> {
         try {
+            // Пустой массив в JavaScript истинен и уезжал в теле запроса как `message_id: []` —
+            // это не документированный режим «очистить весь пакет» (что портал делает с
+            // пустым списком, не проверялось). Считаем пустой список за «очищать нечего»
+            // и до API не доходим: молча сносить весь пакет по пустому списку опасно —
+            // зарезервированный пакет портал повторно не выдаёт
+            if (Array.isArray(messageId) && messageId.length === 0) {
+                return { error: false, message: "Список записей пуст, очищать нечего", data: null };
+            }
+
             const params: any = { process_id: processId };
             if (messageId) {
                 params.message_id = messageId;
             }
-            await this.b24.callMethod("event.offline.clear", params);
+            const response = await this.b24.callMethod("event.offline.clear", params);
+            // «Мягкую» ошибку (например, ERROR_ENTITY_NOT_FOUND на протухшем process_id)
+            // SDK не бросает, а возвращает AjaxResult с isSuccess: false. Без проверки
+            // метод рапортовал бы «События очищены» при неочищенной очереди.
+            // Именно isSuccess, а не getResultData(): та бросает ещё и на result == null,
+            // а что портал кладёт в result этого метода, не проверено
+            if (!response.isSuccess) {
+                const messages = response.getErrorMessages().join("; ") || "неизвестная ошибка";
+                throw new Error(`event.offline.clear: Bitrix24 вернул ошибку — ${messages}`);
+            }
 
             return { error: false, message: "События очищены", data: null };
         } catch (error: any) {

package/logs/logs.ts

@@ -30,6 +30,15 @@ const B24_CLIENT_ID = "6rf74zyu842h6op1z186b08k7aavqq7z";
 /** Лимит длины сообщения для B24 чата (безопасный, с запасом на BB-обёртку) */
 const B24_TEXT_LIMIT = 4000;
 
+/**
+ * Бюджет времени на отправку error-лога в чат B24, мс.
+ *
+ * Своя константа, а не `FETCH_TIMEOUTS` из `utils/fetchRetry.ts`: тот модуль импортирует
+ * `logs` первой строкой, и обратный импорт дал бы цикл. Дублирование одного числа
+ * дешевле цикла зависимостей.
+ */
+const B24_CHAT_TIMEOUT_MS = 5_000;
+
 // ==================== Настройки ====================
 
 const configDir: string = process.env.CONFIG_DIR || "../config";
@@ -149,7 +158,10 @@ class LogsAPI {
 
     /**
      * Отправляет error-сообщение в чат B24 через webhook (fire-and-forget)
-     * Использует нативный fetch, а не fetchRetry — во избежание циклической зависимости
+     * Использует нативный fetch, а не fetchRetry/fetchWithTimeout — во избежание
+     * циклической зависимости, поэтому и таймаут выставляется здесь вручную через
+     * `AbortSignal.timeout`: без него зависшее соединение никого бы не разбудило,
+     * вызов идёт без await
      * Ошибки не пробрасываются, только console.error
      */
     private sendToB24Chat(message: string, jsonData?: unknown): void {
@@ -195,6 +207,7 @@ class LogsAPI {
                 DIALOG_ID: this.b24ChatId,
                 MESSAGE: text,
             }),
+            signal: AbortSignal.timeout(B24_CHAT_TIMEOUT_MS),
         })
             .then((response) => {
                 if (!response.ok) {
@@ -202,6 +215,11 @@ class LogsAPI {
                 }
             })
             .catch((error: unknown) => {
+                // Проверка локальная, без импорта isTimeoutError — тот модуль импортирует logs
+                if ((error as { name?: unknown })?.name === "TimeoutError") {
+                    console.error(`Logs B24 Chat: не ответил за ${B24_CHAT_TIMEOUT_MS / 1000}с, сообщение не доставлено`);
+                    return;
+                }
                 const errMsg = error instanceof Error ? error.message : String(error);
                 console.error(`Logs B24 Chat: ошибка отправки — ${errMsg}`);
             });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andrey4emk/npm-app-back-b24",
-    "version": "3.7.1",
+    "version": "3.8.1",
     "description": "Bitrix24 OAuth helpers for Node.js projects",
     "main": "index.ts",
     "type": "module",
@@ -18,6 +18,9 @@
         "url": "git+ssh://git@github.com/andrey4emk/npm_appBackB24.git"
     },
     "keywords": [],
+    "engines": {
+        "node": ">=20.3.0"
+    },
     "author": "andrey4emk",
     "license": "MIT",
     "bugs": {
@@ -37,7 +40,7 @@
         "utils/fetchRetry.ts"
     ],
     "dependencies": {
-        "@bitrix24/b24jssdk": "2.0.0",
+        "@bitrix24/b24jssdk": "2.2.0",
         "@types/express": "5.0.6",
         "@types/luxon": "3.7.4",
         "@types/node": "25.9.5",

package/sendMessage/chatApp.ts

@@ -1,3 +1,6 @@
+import { fetchWithTimeout, isTimeoutError, FETCH_TIMEOUTS } from "../utils/fetchRetry.ts";
+import { logs } from "../logs/logs.ts";
+
 // ==================== Типы ====================
 
 /** Параметры для создания токена ChatApp */
@@ -85,6 +88,30 @@ export class ChatApp {
         this.telegramType = ChatApp.resolveMessengerType(typeParam?.telegram);
     }
 
+    /**
+     * Общая часть URL до раздела запроса: лицензия и разрешённый тип мессенджера.
+     * `null` — тип из конфига не разрешился, обращаться некуда. Проверка типа идёт
+     * первой: при отсутствующей секции конфига `this.type.whatsApp` тоже undefined,
+     * и до чтения licenseId дело не доходит.
+     */
+    private resolveBaseUrl(messangerType: MessengerType): string | null {
+        const resolvedType = messangerType === "whatsApp" ? this.whatsAppType : this.telegramType;
+        if (!resolvedType) {
+            return null;
+        }
+        const licenseId = messangerType === "whatsApp" ? this.type.whatsApp.licenseId : this.type.telegram.licenseId;
+        return `https://api.chatapp.online/v1/licenses/${licenseId}/messengers/${resolvedType}`;
+    }
+
+    /**
+     * Отказ гейта — один текст на все три публичных метода.
+     * Не бросаем: экземпляр создаётся на уровне модуля, и бросок уронил бы импорт
+     * всего модуля отправки вместе с остальными каналами.
+     */
+    private static denyMessenger(messangerType: MessengerType): ChatAppResult {
+        return { error: true, message: `ChatApp: не разрешён тип мессенджера ${messangerType} (нет конфига или пуст messenger)`, data: null };
+    }
+
     async sendMessageChatApp(messangerType: MessengerType, messageData: MessageData): Promise<ChatAppResult> {
         // Проверяем что верно указан messangerType и в messageData есть phone и message
         if (!["whatsApp", "telegram"].includes(messangerType)) {
@@ -94,9 +121,9 @@ export class ChatApp {
             return { error: true, message: "Отсутствует phone или message", data: null };
         }
         // Тип мессенджера не разрешился из конфига — отправлять некуда
-        const resolvedType = messangerType === "whatsApp" ? this.whatsAppType : this.telegramType;
-        if (!resolvedType) {
-            return { error: true, message: `ChatApp: не разрешён тип мессенджера ${messangerType} (нет конфига или пуст messenger)`, data: null };
+        const baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
         }
 
         const check = await this.checkTokenChatApp();
@@ -107,25 +134,42 @@ export class ChatApp {
         const phone = messageData.phone;
         const message = messageData.message;
 
-        let url: string | undefined;
-        if (messangerType === "whatsApp") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.whatsApp.licenseId}/messengers/${resolvedType}/chats/${phone}/messages/text`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${resolvedType}/chats/${phone}/messages/text`;
-        }
+        const url = `${baseUrl}/chats/${phone}/messages/text`;
 
-        const res = await fetch(url!, {
-            method: "POST",
-            headers: {
-                Lang: "en",
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                Authorization: this.auth.accessToken,
-            },
-            body: JSON.stringify({ text: message }),
-        });
-        const data: any = await res.json();
+        let data: any;
+        try {
+            const res = await fetchWithTimeout(
+                url,
+                {
+                    method: "POST",
+                    headers: {
+                        Lang: "en",
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                        Authorization: this.auth.accessToken,
+                    },
+                    body: JSON.stringify({ text: message }),
+                },
+                FETCH_TIMEOUTS.send
+            );
+            data = await res.json();
+        } catch (error: unknown) {
+            // Метод исторически без try/catch — перехватываем только таймаут, который сами
+            // и вводим. Остальные ошибки летят наружу как раньше
+            if (!isTimeoutError(error)) throw error;
+
+            // Уровень error — единственный, который уходит в чат B24. До появления
+            // таймаута зависание долетало исключением до потребителя и там порождало
+            // задачу через errorB24(); перехватив ошибку здесь, мы обязаны сами оставить
+            // след, иначе правка сделала бы отказ отправки тише, чем он был
+            logs.add(`[${phone}] ChatApp: таймаут ${FETCH_TIMEOUTS.send}мс при отправке сообщения через ${messangerType} — статус неизвестен, повторять нельзя`, "error");
+
+            return {
+                error: true,
+                message: `ChatApp: таймаут ${FETCH_TIMEOUTS.send}мс при отправке сообщения через ${messangerType} — статус неизвестен`,
+                data: null,
+            };
+        }
 
         if (!data.success) {
             return { error: true, message: `Ошибка при отправке сообщения в ChatApp через ${messangerType}`, data };
@@ -149,9 +193,9 @@ export class ChatApp {
             return { error: true, message: "Отсутствует phone или message", data: null };
         }
         // Тип мессенджера не разрешился из конфига — отправлять некуда
-        const resolvedType = messangerType === "whatsApp" ? this.whatsAppType : this.telegramType;
-        if (!resolvedType) {
-            return { error: true, message: `ChatApp: не разрешён тип мессенджера ${messangerType} (нет конфига или пуст messenger)`, data: null };
+        const baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
         }
 
         const check = await this.checkTokenChatApp();
@@ -164,25 +208,38 @@ export class ChatApp {
         const file = messageData.fileUrl;
         const fileName = messageData.fileName;
 
-        let url: string | undefined;
-        if (messangerType === "whatsApp") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.whatsApp.licenseId}/messengers/${resolvedType}/chats/${phone}/messages/file`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${resolvedType}/chats/${phone}/messages/file`;
-        }
+        const url = `${baseUrl}/chats/${phone}/messages/file`;
+
+        let data: any;
+        try {
+            // Файл по ссылке забирает сам ChatApp, поэтому ответа можно ждать дольше — бюджет transfer
+            const res = await fetchWithTimeout(
+                url,
+                {
+                    method: "POST",
+                    headers: {
+                        Lang: "en",
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                        Authorization: this.auth.accessToken,
+                    },
+                    body: JSON.stringify({ file, fileName, caption }),
+                },
+                FETCH_TIMEOUTS.transfer
+            );
+            data = await res.json();
+        } catch (error: unknown) {
+            // Перехватываем только таймаут, остальные ошибки ведут себя как раньше
+            if (!isTimeoutError(error)) throw error;
 
-        const res = await fetch(url!, {
-            method: "POST",
-            headers: {
-                Lang: "en",
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                Authorization: this.auth.accessToken,
-            },
-            body: JSON.stringify({ file, fileName, caption }),
-        });
-        const data: any = await res.json();
+            logs.add(`[${phone}] ChatApp: таймаут ${FETCH_TIMEOUTS.transfer}мс при отправке файла через ${messangerType} — статус неизвестен, повторять нельзя`, "error");
+
+            return {
+                error: true,
+                message: `ChatApp: таймаут ${FETCH_TIMEOUTS.transfer}мс при отправке файла через ${messangerType} — статус неизвестен`,
+                data: null,
+            };
+        }
 
         if (!data.success) {
             return { error: true, message: `Ошибка при отправке сообщения в ChatApp через ${messangerType}`, data };
@@ -197,14 +254,23 @@ export class ChatApp {
         return { error: false, message: `Сообщение успешно отправлено в ChatApp через ${messangerType}`, data, auth: newAuth };
     }
 
+    /**
+     * Проверка телефона. Результат — поле `check` в `data` (значение `data.data.exist` ответа API).
+     *
+     * Изменение поведения от 16.08.2026: ответ с `success: true`, но без объекта `data`
+     * раньше давал `TypeError` наружу (метод не обёрнут в try/catch). Теперь такой ответ
+     * возвращается как обычный для этого класса отказ `{ error: true, ... }` с сырым ответом
+     * в `data`. Молча подставлять `check: undefined` нельзя: «телефон не найден» и «ответ
+     * непонятной формы» — разные факты, и вызывающий отличил бы их только по исключению.
+     */
     async phoneCheckChatApp(messangerType: MessengerType, phone: string): Promise<ChatAppResult> {
         if (!["whatsApp", "telegram"].includes(messangerType)) {
             return { error: true, message: "Неверный тип мессенджера", data: null };
         }
         // Тип мессенджера не разрешился из конфига — проверять телефон негде
-        const resolvedType = messangerType === "whatsApp" ? this.whatsAppType : this.telegramType;
-        if (!resolvedType) {
-            return { error: true, message: `ChatApp: не разрешён тип мессенджера ${messangerType} (нет конфига или пуст messenger)`, data: null };
+        const baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
         }
 
         const check = await this.checkTokenChatApp();
@@ -212,23 +278,32 @@ export class ChatApp {
             return { error: true, message: `Ошибка с токеном ChatApp в функции phoneCheckChatApp класса ChatApp\n${check.message}`, data: check };
         }
 
-        let url: string | undefined;
-        if (messangerType === "whatsApp") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.whatsApp.licenseId}/messengers/${resolvedType}/phones/${phone}/check`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${resolvedType}/phones/${phone}/check`;
-        }
+        const url = `${baseUrl}/phones/${phone}/check`;
 
-        const res = await fetch(url!, {
-            method: "GET",
-            headers: {
-                Lang: "en",
-                Accept: "application/json",
-                Authorization: this.auth.accessToken,
-            },
-        });
-        const data: any = await res.json();
+        let data: any;
+        try {
+            const res = await fetchWithTimeout(
+                url,
+                {
+                    method: "GET",
+                    headers: {
+                        Lang: "en",
+                        Accept: "application/json",
+                        Authorization: this.auth.accessToken,
+                    },
+                },
+                FETCH_TIMEOUTS.api
+            );
+            data = await res.json();
+        } catch (error: unknown) {
+            // Перехватываем только таймаут, остальные ошибки ведут себя как раньше
+            if (!isTimeoutError(error)) throw error;
+
+            // warn, а не error: проверка номера ничего не меняет, повторить её безопасно
+            logs.add(`[${phone}] ChatApp: таймаут ${FETCH_TIMEOUTS.api}мс при проверке телефона через ${messangerType}`, "warn");
+
+            return { error: true, message: `ChatApp: таймаут ${FETCH_TIMEOUTS.api}мс при проверке телефона через ${messangerType}`, data: null };
+        }
 
         if (!data.success) {
             return { error: true, message: `Ошибка при проверке телефона в ChatApp через ${messangerType}`, data };
@@ -240,20 +315,30 @@ export class ChatApp {
             newAuth = this.auth;
             this.updateToken = false;
         }
+        // Ответ разбирается как any — noUncheckedIndexedAccess здесь ничего не ловит,
+        // а обращение к data.data.exist без проверки давало TypeError мимо всякого try/catch
+        if (typeof data.data !== "object" || data.data === null) {
+            return { error: true, message: `Ответ ChatApp без поля data при проверке телефона через ${messangerType}`, data, auth: newAuth };
+        }
+
         data.check = data.data.exist;
         return { error: false, message: `Телефон успешно проверен в ChatApp через ${messangerType}`, data, auth: newAuth };
     }
 
     async checkTokenChatApp(): Promise<{ error: boolean; message: string; data?: null }> {
         try {
-            const response = await fetch("https://api.chatapp.online/v1/tokens/check", {
-                method: "GET",
-                headers: {
-                    Lang: "en",
-                    Accept: "application/json",
-                    Authorization: this.auth.accessToken,
+            const response = await fetchWithTimeout(
+                "https://api.chatapp.online/v1/tokens/check",
+                {
+                    method: "GET",
+                    headers: {
+                        Lang: "en",
+                        Accept: "application/json",
+                        Authorization: this.auth.accessToken,
+                    },
                 },
-            });
+                FETCH_TIMEOUTS.quick
+            );
 
             const data: any = await response.json();
             if (!data.success) {
@@ -270,19 +355,23 @@ export class ChatApp {
     async makeTokenChatApp(): Promise<{ error: boolean; message?: string; data?: unknown }> {
         console.warn("makeTokenChatApp called");
         try {
-            const response = await fetch("https://api.chatapp.online/v1/tokens", {
-                method: "POST",
-                headers: {
-                    Lang: "en",
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
+            const response = await fetchWithTimeout(
+                "https://api.chatapp.online/v1/tokens",
+                {
+                    method: "POST",
+                    headers: {
+                        Lang: "en",
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                    body: JSON.stringify({
+                        email: this.make.email,
+                        password: this.make.pass,
+                        appId: this.make.appId,
+                    }),
                 },
-                body: JSON.stringify({
-                    email: this.make.email,
-                    password: this.make.pass,
-                    appId: this.make.appId,
-                }),
-            });
+                FETCH_TIMEOUTS.quick
+            );
 
             const data: any = await response.json();
             if (!data.success) {
@@ -303,15 +392,19 @@ export class ChatApp {
 
     async refreshTokenChatApp(): Promise<{ error: boolean; message?: string; data?: unknown }> {
         try {
-            const response = await fetch("https://api.chatapp.online/v1/tokens/refresh", {
-                method: "POST",
-                headers: {
-                    Lang: "en",
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
+            const response = await fetchWithTimeout(
+                "https://api.chatapp.online/v1/tokens/refresh",
+                {
+                    method: "POST",
+                    headers: {
+                        Lang: "en",
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                    body: JSON.stringify({ refreshToken: this.auth.refreshToken }),
                 },
-                body: JSON.stringify({ refreshToken: this.auth.refreshToken }),
-            });
+                FETCH_TIMEOUTS.quick
+            );
 
             const data: any = await response.json();
             if (!data.success) {
@@ -336,14 +429,18 @@ export class ChatApp {
 
     async getLicensesChatApp(): Promise<{ error: boolean; message: string; data: unknown }> {
         try {
-            const response = await fetch("https://api.chatapp.online/v1/licenses", {
-                method: "GET",
-                headers: {
-                    Lang: "en",
-                    Accept: "application/json",
-                    Authorization: this.auth.accessToken,
+            const response = await fetchWithTimeout(
+                "https://api.chatapp.online/v1/licenses",
+                {
+                    method: "GET",
+                    headers: {
+                        Lang: "en",
+                        Accept: "application/json",
+                        Authorization: this.auth.accessToken,
+                    },
                 },
-            });
+                FETCH_TIMEOUTS.api
+            );
             const data: any = await response.json();
 
             if (!data.success) {

package/sendMessage/email.ts

@@ -1,4 +1,5 @@
 import nodemailer from "nodemailer";
+import { fetchWithTimeout, FETCH_TIMEOUTS } from "../utils/fetchRetry.ts";
 
 // ==================== Типы ====================
 
@@ -42,6 +43,12 @@ export class Email {
             host: "smtp.yandex.ru",
             port: 465, // 465 = SMTPS, 587 = STARTTLS
             secure: true, // true для 465
+            // Дефолты nodemailer (соединение 2 мин, приветствие 30с, сокет 10 мин) слишком щедры:
+            // письмо с вложением уходит на Яндекс за секунды, а 10 минут молчания сокета
+            // блокируют вызывающую очередь
+            connectionTimeout: 15_000,
+            greetingTimeout: 10_000,
+            socketTimeout: 120_000,
         });
     }
 
@@ -51,7 +58,9 @@ export class Email {
             if (dataMail.fileUrl) {
                 const resDownloadFile = await this.downloadFileToUrl(dataMail.fileUrl);
                 if (resDownloadFile.error) {
-                    return { error: true, message: resDownloadFile.message };
+                    // Подстановка вместо возможного undefined: при exactOptionalPropertyTypes
+                    // у потребителя явный undefined не подходит полю message?: string
+                    return { error: true, message: resDownloadFile.message ?? "Не удалось скачать файл по fileUrl" };
                 }
                 dataMail.attachments = [
                     {
@@ -80,7 +89,7 @@ export class Email {
 
     private async downloadFileToUrl(fileUrl: string): Promise<{ error: boolean; message?: string; buffer?: Buffer }> {
         try {
-            const response = await fetch(fileUrl);
+            const response = await fetchWithTimeout(fileUrl, undefined, FETCH_TIMEOUTS.transfer);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }