@andrey4emk/npm-app-back-b24 3.7.0 → 3.8.0

package/sendMessage/chatApp.ts

@@ -1,3 +1,6 @@
+import { fetchWithTimeout, isTimeoutError, FETCH_TIMEOUTS } from "../utils/fetchRetry.ts";
+import { logs } from "../logs/logs.ts";
+
 // ==================== Типы ====================
 
 /** Параметры для создания токена ChatApp */
@@ -57,12 +60,56 @@ export class ChatApp {
     private auth: ChatAppAuthParam;
     private type: ChatAppTypeParam;
     private updateToken: boolean;
+    private readonly whatsAppType: string | null;
+    private readonly telegramType: string | null;
+
+    /**
+     * Тип мессенджера из конфига. Массив приходит из внешнего источника
+     * (config/chatApp.json обновляется данными API ChatApp), поэтому проверяем:
+     * пустой messenger дал бы URL с undefined и «отправку в никуда».
+     * Не бросаем: экземпляр создаётся на уровне модуля, и бросок уронил бы
+     * импорт всего модуля отправки вместе с остальными каналами. Отказ локальный —
+     * его возвращают методы того мессенджера, который не разрешился.
+     */
+    private static resolveMessengerType(config: MessengerConfig | undefined): string | null {
+        const first = config?.messenger?.[0];
+        if (typeof first?.type !== "string" || !first.type.trim()) {
+            return null;
+        }
+        return first.type;
+    }
 
     constructor(makeParam: ChatAppMakeParam, authParam: ChatAppAuthParam, typeParam: ChatAppTypeParam) {
         this.make = makeParam;
         this.auth = authParam;
         this.type = typeParam;
         this.updateToken = false;
+        this.whatsAppType = ChatApp.resolveMessengerType(typeParam?.whatsApp);
+        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> {
@@ -73,6 +120,11 @@ export class ChatApp {
         if (!messageData.phone || !messageData.message) {
             return { error: true, message: "Отсутствует phone или message", data: null };
         }
+        // Тип мессенджера не разрешился из конфига — отправлять некуда
+        const baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
+        }
 
         const check = await this.checkTokenChatApp();
         if (check.error) {
@@ -82,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/${this.type.whatsApp.messenger[0].type}/chats/${phone}/messages/text`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${this.type.telegram.messenger[0].type}/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 };
@@ -123,6 +192,11 @@ export class ChatApp {
         if (!messageData.phone || !messageData.message) {
             return { error: true, message: "Отсутствует phone или message", data: null };
         }
+        // Тип мессенджера не разрешился из конфига — отправлять некуда
+        const baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
+        }
 
         const check = await this.checkTokenChatApp();
         if (check.error) {
@@ -134,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/${this.type.whatsApp.messenger[0].type}/chats/${phone}/messages/file`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${this.type.telegram.messenger[0].type}/chats/${phone}/messages/file`;
-        }
+        const url = `${baseUrl}/chats/${phone}/messages/file`;
 
-        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();
+        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;
+
+            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 };
@@ -167,33 +254,56 @@ 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 baseUrl = this.resolveBaseUrl(messangerType);
+        if (!baseUrl) {
+            return ChatApp.denyMessenger(messangerType);
+        }
 
         const check = await this.checkTokenChatApp();
         if (check.error) {
             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/${this.type.whatsApp.messenger[0].type}/phones/${phone}/check`;
-        }
-        if (messangerType === "telegram") {
-            url = `https://api.chatapp.online/v1/licenses/${this.type.telegram.licenseId}/messengers/${this.type.telegram.messenger[0].type}/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 };
@@ -205,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) {
@@ -235,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) {
@@ -268,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) {
@@ -301,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}`);
             }

package/sendMessage/smsgold.ts

@@ -1,5 +1,6 @@
 import { getResultData, type B24MethodCaller } from "../bitrix24/b24.ts";
-import { fetchRetry } from "../utils/fetchRetry.ts";
+import { fetchRetry, fetchWithTimeout, isTimeoutError, FETCH_TIMEOUTS } from "../utils/fetchRetry.ts";
+import { logs } from "../logs/logs.ts";
 
 // ==================== Типы ====================
 
@@ -17,6 +18,15 @@ interface SmsMessageData {
     fileName?: string;
 }
 
+/**
+ * Папка на диске Bitrix24, куда кладётся вложение перед отправкой SMS.
+ * Значение — папка «contract_company» проекта «Документы и договора» портала
+ * repacheb.bitrix24.ru. Для опубликованной библиотеки это чужая константа,
+ * поэтому она вынесена в параметр конструктора; здесь она осталась дефолтом,
+ * иначе смена была бы ломающей для всех текущих потребителей.
+ */
+const DEFAULT_UPLOAD_FOLDER_ID = 2792881;
+
 /** Результат отправки SMS */
 interface SmsResult {
     error: boolean;
@@ -27,6 +37,12 @@ interface SmsResult {
         data?: string;
         errorText?: string;
     } | null;
+    /**
+     * Выставляется только при таймауте ожидания ответа SMSGold: запрос ушёл, ответ не пришёл.
+     * Означает «сообщение могло уйти» — не «не отправлено». Повторять отправку нельзя,
+     * решение принимает человек.
+     */
+    unknownDelivery?: boolean;
 }
 
 // ==================== Класс ====================
@@ -37,11 +53,14 @@ export class Smsgold {
     // Структурный тип, а не B24OAuth: объявляет callMethod сам, поэтому переживёт
     // удаление метода из SDK. Сигнатуру конструктора не сужает — она стала шире
     private b24: B24MethodCaller | null;
+    // ID папки на диске B24 для вложений SMS — параметр, а не константа модуля
+    private uploadFolderId: number;
 
-    constructor(authParam: SmsgoldAuthParam, b24: B24MethodCaller | null = null) {
+    constructor(authParam: SmsgoldAuthParam, b24: B24MethodCaller | null = null, uploadFolderId: number = DEFAULT_UPLOAD_FOLDER_ID) {
         this.user = authParam.user;
         this.pass = authParam.pass;
         this.b24 = b24;
+        this.uploadFolderId = uploadFolderId;
     }
 
     async sendSms(messageData: SmsMessageData): Promise<SmsResult> {
@@ -97,13 +116,20 @@ export class Smsgold {
                 sender: "potolkiRepa",
             }).toString();
 
-            const result = await fetch("https://web.smsgold.ru/http2/", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
+            // Отправка неидемпотентна — повторов нет, единственная защита от зависшего
+            // соединения — бюджет времени. 30с взяты с запасом, чтобы «неизвестный статус»
+            // случался как можно реже
+            const result = await fetchWithTimeout(
+                "https://web.smsgold.ru/http2/",
+                {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                    },
+                    body,
                 },
-                body,
-            });
+                FETCH_TIMEOUTS.send
+            );
 
             if (!result.ok) {
                 const errorText = await result.text();
@@ -126,6 +152,23 @@ export class Smsgold {
                 },
             };
         } catch (error: unknown) {
+            // Ответа не дождались: запрос уже ушёл, сообщение могло быть доставлено.
+            // Это не «ошибка отправки» — статус неизвестен, и решить это кодом нельзя.
+            // Единственное место в классе, где пишем в лог: уровень error уходит в чат B24,
+            // потому что разбираться должен человек
+            if (isTimeoutError(error)) {
+                logs.add(
+                    `[${phone}] SMS: таймаут ожидания ответа SMSGold ${FETCH_TIMEOUTS.send}мс — статус неизвестен, повторная отправка запрещена`,
+                    "error"
+                );
+                return {
+                    error: true,
+                    message: `SMSGold не ответил за ${FETCH_TIMEOUTS.send / 1000}с — статус отправки неизвестен: сообщение могло уйти, повторять нельзя`,
+                    result: null,
+                    unknownDelivery: true,
+                };
+            }
+
             const errMsg = error instanceof Error ? error.message : String(error);
             return { error: true, message: errMsg, result: null };
         }
@@ -138,7 +181,7 @@ export class Smsgold {
 
             // Используем метод disk.folder.uploadfile
             const res = await this.b24!.callMethod("disk.folder.uploadfile", {
-                id: 2792881, // Id папки "contract_company" из проекта "Документы и договора"
+                id: this.uploadFolderId,
                 data: { NAME: fileName },
                 fileContent: [fileName, base64File],
             });
@@ -153,9 +196,11 @@ export class Smsgold {
     private async downloadFileToUrl(fileUrl: string): Promise<{ error: boolean; message?: string; buffer?: Buffer }> {
         try {
             // Скачивание файла идемпотентно — повтор при сетевом сбое безопасен.
-            // Отправка SMS (fetch выше по коду) намеренно остаётся без retry:
-            // при потерянном ответе повтор отправил бы сообщение второй раз
-            const response = await fetchRetry(fileUrl);
+            // Отправка SMS (fetchWithTimeout выше по коду) намеренно остаётся без retry:
+            // при потерянном ответе повтор отправил бы сообщение второй раз.
+            // Попыток 3, а не 5: при бюджете 60с на попытку пять попыток дали бы до пяти
+            // минут ожидания перед самой отправкой SMS
+            const response = await fetchRetry(fileUrl, undefined, 3, 500, FETCH_TIMEOUTS.transfer);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }