@andrey4emk/npm-app-back-b24 2.0.3 → 2.0.7

package/README.md

@@ -15,6 +15,7 @@
     -   [Email](#email)
     -   [Wappi](#wappi)
     -   [Логирование](#логирование)
+    -   [fetchRetry](#fetchretry)
 -   [Переменные окружения](#переменные-окружения)
 -   [Скрипты](#скрипты)
 -   [Лицензия](#лицензия)
@@ -40,6 +41,7 @@ import {
     Email,
     Wappi,
     logs,
+    fetchRetry,
 } from "@andrey4emk/npm-app-back-b24";
 
 // $b24 — готовый экземпляр B24OAuth (или null, если токены не настроены)
@@ -86,6 +88,9 @@ await wappi.sendMessageWappi("whatsApp", { phone: "+1234567890", message: "Пр
 
 // Логирование
 logs.add("Сообщение", "info");
+
+// fetch с повторными попытками при сетевых ошибках
+const response = await fetchRetry("https://api.example.com/data", { method: "GET" });
 ```
 
 ## API
@@ -561,6 +566,46 @@ logs.add("Сообщение", "info");
     -   Конфигурация хранится в файле `log.json` (через `conf`).
     -   Каждый уровень можно включить/выключить, изменить цвет.
 
+### fetchRetry
+
+-   **`fetchRetry(url, options?, retries?, delay?)`** — обёртка над `fetch` с повторными попытками при сетевых ошибках. HTTP-ошибки (4xx, 5xx) **не** вызывают повторных попыток — повторяются только сетевые сбои (TypeError, ECONNRESET, ETIMEDOUT и т.д.).
+
+    -   **Параметры:**
+
+        | Параметр  | Тип                          | По умолчанию  | Описание                          |
+        | --------- | ---------------------------- | ------------- | --------------------------------- |
+        | `url`     | string \| URL \| Request     | **обязательно** | Адрес запроса                   |
+        | `options` | RequestInit                  | `undefined`   | Параметры fetch (метод, заголовки, body и т.д.) |
+        | `retries` | number                       | `5`           | Количество попыток               |
+        | `delay`   | number                       | `500`         | Задержка между попытками (мс)    |
+
+    -   **Возвращает:** `Promise<Response>` — ответ от fetch.
+
+    -   **Обрабатываемые сетевые ошибки:**
+        `ECONNRESET`, `ECONNREFUSED`, `ETIMEDOUT`, `ENOTFOUND`, `ENETUNREACH`, `EAI_AGAIN`, `UND_ERR_CONNECT_TIMEOUT`, `UND_ERR_SOCKET`, `TypeError`, а также ошибки с сообщениями `fetch failed`, `network`, `socket`.
+
+    -   **Логирование:** при каждой неудачной попытке записывает сообщение через `logs.add()` с уровнем `error`.
+
+    ```js
+    import { fetchRetry } from "@andrey4emk/npm-app-back-b24";
+
+    // Простой GET-запрос с дефолтными параметрами (5 попыток, 500мс)
+    const response = await fetchRetry("https://api.example.com/data");
+    const json = await response.json();
+
+    // POST-запрос с кастомными параметрами
+    const res = await fetchRetry(
+        "https://api.example.com/webhook",
+        {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: "value" }),
+        },
+        3,   // 3 попытки
+        1000 // 1 секунда между попытками
+    );
+    ```
+
 ## Переменные окружения
 
 | Переменная                  | Назначение                                                    |

package/bitrix24/errTaskB24.ts

@@ -20,7 +20,7 @@ export interface ErrorTaskData {
     /** Значение для UF_CRM_TASK (массив или строка). Приоритетнее entityTypeAbbr */
     ufCrmTask?: string[] | string;
     /** @deprecated Используйте ufCrmTask. Код CRM сущности для UF_CRM_TASK */
-    entityTypeAbbr?: string;
+    entityTypeAbbr?: never;
 }
 
 /** Результат создания задачи */

package/index.ts

@@ -5,11 +5,14 @@ export * from "./bitrix24/b24.ts";
 export * from "./bitrix24/errTaskB24.ts";
 export * from "./bitrix24/eventB24.ts";
 
-// Мессенджеры и уведомления (пока .js)
-export * from "./sendMessage/chatApp.js";
-export * from "./sendMessage/smsgold.js";
-export * from "./sendMessage/email.js";
-export * from "./sendMessage/wappi.js";
+// Мессенджеры и уведомления
+export * from "./sendMessage/chatApp.ts";
+export * from "./sendMessage/smsgold.ts";
+export * from "./sendMessage/email.ts";
+export * from "./sendMessage/wappi.ts";
 
 // Логирование
 export * from "./logs/logs.ts";
+
+// Утилиты
+export * from "./utils/fetchRetry.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andrey4emk/npm-app-back-b24",
-    "version": "2.0.3",
+    "version": "2.0.7",
     "description": "Bitrix24 OAuth helpers for Node.js projects",
     "main": "index.ts",
     "type": "module",
@@ -27,20 +27,24 @@
         "bitrix24/b24.ts",
         "bitrix24/errTaskB24.ts",
         "bitrix24/eventB24.ts",
-        "sendMessage/chatApp.js",
-        "sendMessage/smsgold.js",
-        "sendMessage/email.js",
-        "sendMessage/wappi.js",
-        "logs/logs.ts"
+        "sendMessage/chatApp.ts",
+        "sendMessage/smsgold.ts",
+        "sendMessage/email.ts",
+        "sendMessage/wappi.ts",
+        "logs/logs.ts",
+        "utils/fetchRetry.ts"
     ],
     "dependencies": {
         "@bitrix24/b24jssdk": "^0.5.1",
         "@types/express": "^5.0.6",
         "@types/luxon": "^3.7.1",
         "@types/node": "^25.0.10",
-        "luxon": "^3.4.4",
+        "conf": "^15.0.2",
         "dotenv": "^17.2.3",
-        "nodemailer": "^7.0.6",
-        "conf": "^15.0.2"
+        "luxon": "^3.4.4",
+        "nodemailer": "^7.0.6"
+    },
+    "devDependencies": {
+        "@types/nodemailer": "^7.0.9"
     }
 }

package/sendMessage/chatApp.ts

@@ -0,0 +1,323 @@
+// ==================== Типы ====================
+
+/** Параметры для создания токена ChatApp */
+interface ChatAppMakeParam {
+    email: string;
+    pass: string;
+    appId: string;
+}
+
+/** Данные авторизации ChatApp */
+interface ChatAppAuthParam {
+    accessToken: string;
+    accessTokenEndTime: string;
+    refreshToken: string;
+    refreshTokenEndTime: string;
+}
+
+/** Параметры мессенджера */
+interface MessengerConfig {
+    licenseId: string;
+    messenger: { type: string }[];
+}
+
+/** Типы мессенджеров для ChatApp */
+interface ChatAppTypeParam {
+    whatsApp: MessengerConfig;
+    telegram: MessengerConfig;
+}
+
+/** Тип мессенджера */
+type MessengerType = "whatsApp" | "telegram";
+
+/** Данные для отправки текстового сообщения */
+interface MessageData {
+    phone: string;
+    message: string;
+}
+
+/** Данные для отправки файла */
+interface FileMessageData extends MessageData {
+    fileUrl: string;
+    fileName: string;
+}
+
+/** Стандартный результат операции */
+interface ChatAppResult {
+    error: boolean;
+    message: string;
+    data: unknown;
+    auth?: ChatAppAuthParam | null;
+}
+
+// ==================== Класс ====================
+
+export class ChatApp {
+    private make: ChatAppMakeParam;
+    private auth: ChatAppAuthParam;
+    private type: ChatAppTypeParam;
+    private updateToken: boolean;
+
+    constructor(makeParam: ChatAppMakeParam, authParam: ChatAppAuthParam, typeParam: ChatAppTypeParam) {
+        this.make = makeParam;
+        this.auth = authParam;
+        this.type = typeParam;
+        this.updateToken = false;
+    }
+
+    async sendMessageChatApp(messangerType: MessengerType, messageData: MessageData): Promise<ChatAppResult> {
+        // Проверяем что верно указан messangerType и в messageData есть phone и message
+        if (!["whatsApp", "telegram"].includes(messangerType)) {
+            return { error: true, message: "Неверный тип мессенджера", data: null };
+        }
+        if (!messageData.phone || !messageData.message) {
+            return { error: true, message: "Отсутствует phone или message", data: null };
+        }
+
+        const check = await this.checkTokenChatApp();
+        if (check.error) {
+            return { error: true, message: `Ошибка с токеном ChatApp в функции sendMessageChatApp класса ChatApp\n${check.message}`, data: null };
+        }
+
+        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 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();
+
+        if (!data.success) {
+            return { error: true, message: `Ошибка при отправке сообщения в ChatApp через ${messangerType}`, data };
+        }
+
+        // Если в процессе запроса обновили токен, то возвращаем информацию об этом
+        let newAuth: ChatAppAuthParam | null = null;
+        if (this.updateToken) {
+            newAuth = this.auth;
+            this.updateToken = false;
+        }
+        return { error: false, message: `Сообщение успешно отправлено в ChatApp через ${messangerType}`, data, auth: newAuth };
+    }
+
+    async sendFileChatApp(messangerType: MessengerType, messageData: FileMessageData): Promise<ChatAppResult> {
+        // Проверяем что верно указан messangerType и в messageData есть phone и message
+        if (!["whatsApp", "telegram"].includes(messangerType)) {
+            return { error: true, message: "Неверный тип мессенджера", data: null };
+        }
+        if (!messageData.phone || !messageData.message) {
+            return { error: true, message: "Отсутствует phone или message", data: null };
+        }
+
+        const check = await this.checkTokenChatApp();
+        if (check.error) {
+            return { error: true, message: `Ошибка с токеном ChatApp в функции sendMessageChatApp класса ChatApp\n${check.message}`, data: null };
+        }
+
+        const phone = messageData.phone;
+        const caption = messageData.message;
+        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 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();
+
+        if (!data.success) {
+            return { error: true, message: `Ошибка при отправке сообщения в ChatApp через ${messangerType}`, data };
+        }
+
+        // Если в процессе запроса обновили токен, то возвращаем информацию об этом
+        let newAuth: ChatAppAuthParam | null = null;
+        if (this.updateToken) {
+            newAuth = this.auth;
+            this.updateToken = false;
+        }
+        return { error: false, message: `Сообщение успешно отправлено в ChatApp через ${messangerType}`, data, auth: newAuth };
+    }
+
+    async phoneCheckChatApp(messangerType: MessengerType, phone: string): Promise<ChatAppResult> {
+        if (!["whatsApp", "telegram"].includes(messangerType)) {
+            return { error: true, message: "Неверный тип мессенджера", data: null };
+        }
+
+        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 res = await fetch(url!, {
+            method: "GET",
+            headers: {
+                Lang: "en",
+                Accept: "application/json",
+                Authorization: this.auth.accessToken,
+            },
+        });
+        const data: any = await res.json();
+
+        if (!data.success) {
+            return { error: true, message: `Ошибка при проверке телефона в ChatApp через ${messangerType}`, data };
+        }
+
+        // Если в процессе запроса обновили токен, то возвращаем информацию об этом
+        let newAuth: ChatAppAuthParam | null = null;
+        if (this.updateToken) {
+            newAuth = this.auth;
+            this.updateToken = false;
+        }
+        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 data: any = await response.json();
+            if (!data.success) {
+                await this.refreshTokenChatApp();
+                return { error: false, message: "Токен обновлен" };
+            }
+            return { error: false, message: "Токен действителен" };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message, data: null };
+        }
+    }
+
+    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",
+                },
+                body: JSON.stringify({
+                    email: this.make.email,
+                    password: this.make.pass,
+                    appId: this.make.appId,
+                }),
+            });
+
+            const data: any = await response.json();
+            if (!data.success) {
+                return { error: true, message: "Не удалось получить токен ChatApp", data };
+            }
+
+            this.auth.accessToken = data.data.accessToken;
+            this.auth.accessTokenEndTime = data.data.accessTokenEndTime;
+            this.auth.refreshToken = data.data.refreshToken;
+            this.auth.refreshTokenEndTime = data.data.refreshTokenEndTime;
+            this.updateToken = true;
+            return { error: false };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message, data: null };
+        }
+    }
+
+    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",
+                },
+                body: JSON.stringify({ refreshToken: this.auth.refreshToken }),
+            });
+
+            const data: any = await response.json();
+            if (!data.success) {
+                const resMakeToken = await this.makeTokenChatApp();
+                if (resMakeToken.error) {
+                    return { error: true, message: "Не удалось обновить токен ChatApp", data };
+                }
+                return { error: false };
+            }
+
+            this.auth.accessToken = data.data.accessToken;
+            this.auth.accessTokenEndTime = data.data.accessTokenEndTime;
+            this.auth.refreshToken = data.data.refreshToken;
+            this.auth.refreshTokenEndTime = data.data.refreshTokenEndTime;
+            this.updateToken = true;
+            return { error: false };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message, data: null };
+        }
+    }
+
+    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 data: any = await response.json();
+
+            if (!data.success) {
+                return { error: true, message: "Не удалось получить лицензии ChatApp", data: null };
+            }
+            return { error: false, message: "Лицензии успешно получены", data: data.licenses };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message, data: null };
+        }
+    }
+}

package/sendMessage/email.ts

@@ -0,0 +1,97 @@
+import nodemailer from "nodemailer";
+
+// ==================== Типы ====================
+
+/** Параметры авторизации почты */
+interface EmailAuthParam {
+    user: string;
+    pass: string;
+}
+
+/** Данные для отправки письма */
+interface EmailData {
+    to: string;
+    subject: string;
+    text?: string;
+    html?: string;
+    fileUrl?: string;
+    fileName?: string;
+    attachments?: { filename: string; content: Buffer }[] | null;
+}
+
+/** Результат отправки письма */
+interface EmailResult {
+    error: boolean;
+    message?: string;
+    info?: unknown;
+}
+
+// ==================== Класс ====================
+
+export class Email {
+    private auth: EmailAuthParam;
+    private transporter: ReturnType<typeof nodemailer.createTransport>;
+
+    constructor(auth: EmailAuthParam) {
+        this.auth = auth;
+        this.transporter = nodemailer.createTransport({
+            auth: {
+                user: this.auth.user,
+                pass: this.auth.pass,
+            },
+            host: "smtp.yandex.ru",
+            port: 465, // 465 = SMTPS, 587 = STARTTLS
+            secure: true, // true для 465
+        });
+    }
+
+    async send(dataMail: EmailData): Promise<EmailResult> {
+        try {
+            // Если прислали ссылку на файл, то скачиваем его и добавляем в attachments
+            if (dataMail.fileUrl) {
+                const resDownloadFile = await this.downloadFileToUrl(dataMail.fileUrl);
+                if (resDownloadFile.error) {
+                    return { error: true, message: resDownloadFile.message };
+                }
+                dataMail.attachments = [
+                    {
+                        filename: dataMail.fileName!,
+                        content: resDownloadFile.buffer!,
+                    },
+                ];
+            } else {
+                dataMail.attachments = null;
+            }
+
+            const info = await this.transporter.sendMail({
+                from: `Натяжные потолки Репа. <${this.auth.user}>`,
+                to: [dataMail.to, this.auth.user],
+                subject: dataMail.subject,
+                text: dataMail.text,
+                html: dataMail.html,
+                attachments: dataMail.attachments ?? undefined,
+            });
+            return { error: false, info };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message };
+        }
+    }
+
+    private async downloadFileToUrl(fileUrl: string): Promise<{ error: boolean; message?: string; buffer?: Buffer }> {
+        try {
+            const response = await fetch(fileUrl);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+
+            // Возвращаем буфер
+            return { error: false, buffer };
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { error: true, message: `Ошибка при скачивании файла по fileUrl: ${message}` };
+        }
+    }
+}