@gamastudio/sendwave-provider 0.0.2

package/build/provider/sender.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessage = void 0;
+const https_1 = require("https");
+const axios_1 = __importDefault(require("axios"));
+const detectorMedia_1 = require("../utils/detectorMedia");
+class SenderMessage {
+    constructor(args) {
+        this.sendwaveApi = axios_1.default.create({
+            baseURL: args.url,
+            httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
+            headers: {
+                "Content-Type": "application/json",
+                apikey: args.apiKey,
+            },
+        });
+        this.globalVendorArgs = args;
+    }
+    async sendPresence(data) {
+        var _a, _b;
+        try {
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/chat/sendPresence/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from,
+                delay: data.delay || 2000,
+                presence: data.presence || "composing",
+            }));
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendText(data) {
+        var _a, _b, _c;
+        try {
+            await this.sendPresence({
+                from: data.from,
+                presence: "composing",
+                delay: data.delay || 2000,
+            });
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendText/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from.split("@")[0],
+                text: data.text,
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (e) {
+            console.error((_c = e === null || e === void 0 ? void 0 : e.response) === null || _c === void 0 ? void 0 : _c.data);
+        }
+    }
+    async sendList(data) {
+        var _a, _b, _c, _d, _e;
+        try {
+            if (!(data === null || data === void 0 ? void 0 : data.from))
+                throw new Error("sendList: falta 'from'");
+            if (!(data === null || data === void 0 ? void 0 : data.list))
+                throw new Error("sendList: falta 'list'");
+            const { title, description = "", footerText = "", button, content = [], } = data.list;
+            if (!Array.isArray(content) || content.length === 0)
+                throw new Error("sendList: 'content' debe ser un array no vacío");
+            const isSimple = typeof content[0] === "string";
+            const sections = isSimple
+                ? [
+                    {
+                        title: "",
+                        rows: content.map((t, i) => ({
+                            rowId: `${i + 1}`,
+                            title: t,
+                        })),
+                    },
+                ]
+                : content.map((sec) => ({
+                    title: sec.title || "",
+                    rows: (sec.rows || []).map((r, i) => ({
+                        rowId: `${i + 1}`,
+                        title: r.title || "",
+                        ...(r.description && r.description.trim()
+                            ? { description: r.description.trim() }
+                            : {}),
+                    })),
+                }));
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendList/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from.split("@")[0],
+                title,
+                description,
+                footerText,
+                buttonText: button,
+                sections,
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (err) {
+            console.error("[sendList Error]", ((_e = (_d = (_c = err.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.response) === null || _e === void 0 ? void 0 : _e.message) || err.message);
+        }
+    }
+    async sendMedia(data) {
+        var _a, _b;
+        try {
+            const { media, mimeType, mediaType } = await detectorMedia_1.detectorMedia.processMedia(data.url);
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendMedia/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from.split("@")[0],
+                caption: data.text,
+                mediatype: mediaType,
+                mimetype: mimeType,
+                media: media,
+                fileName: data.fileName || crypto.randomUUID(),
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendFile(data) {
+        try {
+            return await this.sendMedia({
+                ...data,
+                fileName: data.fileName || crypto.randomUUID(),
+                mediaType: "document",
+            });
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendImage(data) {
+        try {
+            return await this.sendMedia({
+                ...data,
+                mediaType: "image",
+            });
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendAudio(data) {
+        try {
+            return await this.sendMedia({
+                ...data,
+                mediaType: "audio",
+            });
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendVideo(data) {
+        try {
+            return await this.sendMedia({
+                ...data,
+                mediaType: "video",
+            });
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendVoice(data) {
+        var _a, _b;
+        try {
+            const { media } = await detectorMedia_1.detectorMedia.processMedia(data.url);
+            await this.sendPresence({
+                from: data.from,
+                presence: "recording",
+                delay: data.delay || 2000,
+            });
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendWhatsAppAudio/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from,
+                audio: media,
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (e) {
+            console.error(e.response.data.response.message);
+        }
+    }
+    async sendButton(data) {
+        var _a, _b;
+        try {
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendButtons/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from.split("@")[0],
+                title: data.title,
+                body: data.body,
+                description: data.description,
+                footer: data.footer,
+                buttons: data.buttons.map((button, index) => ({
+                    type: button.type,
+                    title: button.text,
+                    displayText: button.text,
+                    id: `${index + 1}`,
+                })),
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (error) {
+            console.error(error.response.data.response.message);
+        }
+    }
+}
+exports.SenderMessage = SenderMessage;

package/build/utils/detectorMedia.d.ts

@@ -0,0 +1,24 @@
+interface DetectorMediaProps {
+    media?: string;
+    mimeType?: string;
+    mediaType?: string;
+    fileName?: string;
+}
+export declare class DetectorMedia {
+    static instance: DetectorMedia;
+    static getInstance(): DetectorMedia;
+    isRemoteUrl(url: string): boolean;
+    convertPathToBase64(filePath: string): Promise<DetectorMediaProps>;
+    getMimeTypeFromUrl(url: string): Promise<string | null>;
+    extractFileNameFromUrl(url: string): Promise<string>;
+    /**
+     * Método unificado que acepta path o url y devuelve:
+     * - media (base64 si es path, url si es remota)
+     * - mimeType
+     * - fileName
+     */
+    processMedia(input: string): Promise<DetectorMediaProps>;
+    mapMimeToCategory(mimeType: string): "image" | "video" | "audio" | "document" | "unknown";
+}
+export declare const detectorMedia: DetectorMedia;
+export {};

package/build/utils/detectorMedia.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectorMedia = exports.DetectorMedia = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const axios_1 = __importDefault(require("axios"));
+class DetectorMedia {
+    static getInstance() {
+        if (!DetectorMedia.instance) {
+            DetectorMedia.instance = new DetectorMedia();
+        }
+        return DetectorMedia.instance;
+    }
+    isRemoteUrl(url) {
+        try {
+            const u = new URL(url);
+            return u.protocol === "http:" || u.protocol === "https:";
+        }
+        catch {
+            return false;
+        }
+    }
+    async convertPathToBase64(filePath) {
+        const fileBuffer = await promises_1.default.readFile(filePath);
+        const mediaType = this.mapMimeToCategory(mime_types_1.default.lookup(filePath).toString());
+        if (!mediaType)
+            throw new Error("No se pudo determinar el tipo MIME del archivo");
+        const base64Data = fileBuffer.toString("base64");
+        const media = base64Data;
+        const fileName = path_1.default.basename(filePath);
+        return {
+            media,
+            mediaType,
+            fileName,
+            mimeType: mime_types_1.default.lookup(filePath).toString(),
+        };
+    }
+    async getMimeTypeFromUrl(url) {
+        try {
+            const res = await axios_1.default.head(url);
+            const mediaType = this.mapMimeToCategory(res.headers["content-type"]);
+            return mediaType || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async extractFileNameFromUrl(url) {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname;
+        const name = pathname.split("/").pop();
+        return name || `file_${Date.now()}`;
+    }
+    /**
+     * Método unificado que acepta path o url y devuelve:
+     * - media (base64 si es path, url si es remota)
+     * - mimeType
+     * - fileName
+     */
+    async processMedia(input) {
+        if (this.isRemoteUrl(input)) {
+            const mediaType = await this.getMimeTypeFromUrl(input);
+            if (!mediaType)
+                throw new Error("No se pudo determinar el tipo MIME de la URL remota");
+            const fileName = await this.extractFileNameFromUrl(input);
+            return {
+                media: input,
+                mimeType: mime_types_1.default.lookup(input).toString(),
+                fileName,
+                mediaType,
+            };
+        }
+        return this.convertPathToBase64(input);
+    }
+    mapMimeToCategory(mimeType) {
+        if (mimeType.startsWith("image/"))
+            return "image";
+        if (mimeType.startsWith("video/"))
+            return "video";
+        if (mimeType.startsWith("audio/"))
+            return "audio";
+        if (mimeType.startsWith("application/") || mimeType.startsWith("text/"))
+            return "document";
+        return "unknown";
+    }
+}
+exports.DetectorMedia = DetectorMedia;
+exports.detectorMedia = DetectorMedia.getInstance();

package/build/utils/parserMsg.d.ts

@@ -0,0 +1,2 @@
+import { ParsedMessage } from "../core/interface/parser.interface";
+export declare function parseIncomingMsg(payload: any): ParsedMessage | null;

package/build/utils/parserMsg.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncomingMsg = parseIncomingMsg;
+const bot_1 = require("@builderbot/bot"); // Asegúrate de importar utils correctamente
+function parseIncomingMsg(payload) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    try {
+        const msg = payload.data;
+        if (msg.messageType === "reactionMessage")
+            return null;
+        if (!msg) {
+            return null;
+        }
+        // if (msg.key.fromMe) return null
+        const fromMe = msg.key.fromMe;
+        const from = (_a = msg.key) === null || _a === void 0 ? void 0 : _a.remoteJid.split("@")[0];
+        const to = payload.instance || "";
+        const name = msg.pushName;
+        const messageContent = msg.message || {};
+        const messageType = msg.messageType || Object.keys(messageContent)[0];
+        let body = "";
+        let type = messageType;
+        let media;
+        let caption;
+        // 🎯 Primero detección especial de eventos por tipo de mensaje
+        if (messageContent.locationMessage) {
+            body = bot_1.utils.generateRefProvider("_event_location_");
+            type = "locationMessage";
+        }
+        else if (messageContent.orderMessage) {
+            body = bot_1.utils.generateRefProvider("_event_order_");
+            type = "orderMessage";
+        }
+        else if (messageContent.videoMessage) {
+            body = bot_1.utils.generateRefProvider("_event_media_");
+            type = "videoMessage";
+            media = (_b = messageContent.videoMessage) === null || _b === void 0 ? void 0 : _b.url;
+            caption = ((_c = messageContent.videoMessage) === null || _c === void 0 ? void 0 : _c.caption) || "";
+        }
+        else if (messageContent.stickerMessage) {
+            body = bot_1.utils.generateRefProvider("_event_media_");
+            type = "stickerMessage";
+            media = (_d = messageContent.stickerMessage) === null || _d === void 0 ? void 0 : _d.url;
+        }
+        else if (messageContent.imageMessage) {
+            body = bot_1.utils.generateRefProvider("_event_media_");
+            type = "imageMessage";
+            media = (_e = messageContent.imageMessage) === null || _e === void 0 ? void 0 : _e.url;
+            caption = ((_f = messageContent.imageMessage) === null || _f === void 0 ? void 0 : _f.caption) || "";
+        }
+        else if (messageContent.documentMessage ||
+            messageContent.documentWithCaptionMessage) {
+            body = bot_1.utils.generateRefProvider("_event_document_");
+            type = "documentMessage";
+            media =
+                ((_g = messageContent.documentMessage) === null || _g === void 0 ? void 0 : _g.url) ||
+                    ((_h = messageContent.documentWithCaptionMessage) === null || _h === void 0 ? void 0 : _h.url);
+            caption =
+                ((_j = messageContent.documentMessage) === null || _j === void 0 ? void 0 : _j.caption) ||
+                    ((_k = messageContent.documentWithCaptionMessage) === null || _k === void 0 ? void 0 : _k.caption) ||
+                    "";
+        }
+        else if (messageContent.audioMessage) {
+            body = bot_1.utils.generateRefProvider("_event_voice_note_");
+            type = "audioMessage";
+            media = (_l = messageContent.audioMessage) === null || _l === void 0 ? void 0 : _l.url;
+        }
+        else {
+            // 🎯 Si no es media especial, hacer parsing normal por tipo
+            switch (type) {
+                case "conversation":
+                    body = messageContent.conversation || "";
+                    break;
+                case "buttonsResponseMessage":
+                    body = ((_m = messageContent.buttonsResponseMessage) === null || _m === void 0 ? void 0 : _m.selectedButtonId) || "";
+                    break;
+                case "listResponseMessage":
+                    body = ((_o = messageContent.listResponseMessage) === null || _o === void 0 ? void 0 : _o.title) || "";
+                    break;
+                case "listMessage":
+                    body =
+                        `${(_p = messageContent.listMessage) === null || _p === void 0 ? void 0 : _p.title}${((_q = messageContent.listMessage) === null || _q === void 0 ? void 0 : _q.title) ? "\n" : ""}${(_r = messageContent.listMessage) === null || _r === void 0 ? void 0 : _r.description}` || "";
+                    break;
+                default:
+                    body = "Tipo de mensaje no soportado aún";
+            }
+        }
+        return {
+            fromMe,
+            from,
+            to,
+            name,
+            body,
+            type,
+            media,
+            caption,
+            // originalPayload: payload,
+        };
+    }
+    catch (error) {
+        console.error("[parseIncomingMsg] Error:", error);
+        return null;
+    }
+}

package/build/utils/queueFlow.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from "events";
+import { SendWaveProvider } from "../provider/provider";
+interface QueueFlowConfig {
+    warningTimeout?: number;
+    endTimeout?: number;
+    warningMessage?: string;
+}
+declare class QueueFlow extends EventEmitter {
+    static instance: QueueFlow;
+    private userTimeouts;
+    ignoredUsers: Set<string>;
+    private config;
+    constructor(config?: QueueFlowConfig);
+    static getInstance(config?: QueueFlowConfig): QueueFlow;
+    updateConfig(config: Partial<QueueFlowConfig>): void;
+    clearUserTimeout(from: string): void;
+    resetUserTimeout: ({ provider, from, name, }: {
+        from: string;
+        provider: SendWaveProvider;
+        name?: string;
+    }) => {
+        isActive: boolean;
+        from: string;
+        name: string | undefined;
+    };
+    forceClearUser(from: string): void;
+    removeUserListeners(from: string): void;
+    getUserStats(): {
+        activeTimeouts: number;
+        ignoredUsers: number;
+        config: Required<QueueFlowConfig>;
+    };
+    isUserIgnored(from: string): boolean;
+}
+export declare const queueFlow: QueueFlow;
+export { QueueFlow, type QueueFlowConfig };

package/build/utils/queueFlow.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueFlow = exports.queueFlow = void 0;
+const events_1 = require("events");
+class QueueFlow extends events_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.userTimeouts = new Map();
+        this.ignoredUsers = new Set();
+        this.resetUserTimeout = ({ provider, from, name, }) => {
+            this.clearUserTimeout(from);
+            let isActive = true;
+            // 🔥 Timeout de advertencia (configurable)
+            const warningTimeout = setTimeout(async () => {
+                await provider.sendText({
+                    from,
+                    text: this.config.warningMessage,
+                });
+                this.emit(`userInactive-${from}`, { from, name, isActive: true });
+                // 🔥 Timeout para finalizar flujo (configurable después)
+                const endTimeout = setTimeout(async () => {
+                    // 1. Marcar como ignorado INMEDIATAMENTE
+                    this.ignoredUsers.add(from);
+                    // 2. Esperar un momento para que se registre el ignore
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                    // 3. Limpiar listeners
+                    this.removeUserListeners(from);
+                    // 4. Enviar flow para que ejecute endFlow correctamente
+                    provider.sendFlow({ event: "END_FLOW", from, name: name || "" });
+                    // 5. Emitir evento
+                    this.emit(`userInactive-${from}`, { from, name, isActive: false });
+                }, this.config.endTimeout);
+                this.userTimeouts.set(from, endTimeout);
+            }, this.config.warningTimeout);
+            this.userTimeouts.set(from, warningTimeout);
+            return { isActive, from, name };
+        };
+        this.config = {
+            warningTimeout: config.warningTimeout || 30 * 60 * 1000, // 30 minutes
+            endTimeout: config.endTimeout || 2 * 60 * 1000, // 2 minutes
+            warningMessage: config.warningMessage || "⏳ Parece que has estado inactivo. ¿Sigues ahí?",
+        };
+    }
+    static getInstance(config) {
+        if (!this.instance) {
+            this.instance = new QueueFlow(config);
+        }
+        return this.instance;
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    clearUserTimeout(from) {
+        if (this.userTimeouts.has(from)) {
+            clearTimeout(this.userTimeouts.get(from));
+            this.userTimeouts.delete(from);
+        }
+    }
+    forceClearUser(from) {
+        this.clearUserTimeout(from);
+        this.removeUserListeners(from);
+    }
+    removeUserListeners(from) {
+        // 🔥 Eliminar todos los listeners de este usuario
+        this.removeAllListeners(`userInactive-${from}`);
+        this.removeAllListeners(`forceClearTimeout-${from}`);
+        this.userTimeouts.delete(from);
+        this.ignoredUsers.delete(from);
+    }
+    getUserStats() {
+        return {
+            activeTimeouts: this.userTimeouts.size,
+            ignoredUsers: this.ignoredUsers.size,
+            config: this.config,
+        };
+    }
+    isUserIgnored(from) {
+        return this.ignoredUsers.has(from);
+    }
+}
+exports.QueueFlow = QueueFlow;
+exports.queueFlow = QueueFlow.getInstance();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@gamastudio/sendwave-provider",
+  "version": "0.0.2",
+  "description": "Librería para interactuar con Sendwave usando configuración dinámica.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias && copyfiles package.json build",
+    "test": "ts-node -r tsconfig-paths/register test/test.ts",
+    "dev": "ts-node-dev --respawn --transpile-only -r tsconfig-paths/register test/test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "Sendwave",
+    "Provider",
+    "Gamastudio",
+    "Bot"
+  ],
+  "author": "Ameth Galarcio <amethgm@gmail.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@builderbot/bot": "^1.3.1",
+    "@gamastudio/colorslog": "^0.1.6",
+    "@types/mime-types": "^2.1.4",
+    "axios": "^1.11.0",
+    "body-parser": "^2.2.0",
+    "cors": "^2.8.5",
+    "file-type": "^20.5.0",
+    "mime-types": "^3.0.1",
+    "queue-promise": "^2.2.1",
+    "sirv": "^3.0.1"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.14.4",
+    "@types/body-parser": "^1.19.6",
+    "@types/cors": "^2.8.19",
+    "@types/node": "^22.18.0",
+    "copyfiles": "^2.4.1",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "tsc-alias": "^1.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "paths": {
+      "@provider/*": ["provider/*"],
+      "@interface/*": ["interface/*"],
+      "@utils/*": ["utils/*"],
+      "@core/*": ["core/*"]
+    },
+    "outDir": "build",
+    "module": "CommonJS",
+    "target": "ES2019",
+    "declaration": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}