@gamastudio/sendwave-provider 1.0.2 → 1.0.4

package/build/application/messaging/message-sender.service.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageSenderService = void 0;
+const text_strategy_1 = require("./strategies/text.strategy");
+const presence_strategy_1 = require("./strategies/presence.strategy");
+const media_strategy_1 = require("./strategies/media.strategy");
+const voice_strategy_1 = require("./strategies/voice.strategy");
+const list_strategy_1 = require("./strategies/list.strategy");
+const interactive_strategy_1 = require("./strategies/interactive.strategy");
+const misc_strategy_1 = require("./strategies/misc.strategy");
+class MessageSenderService {
+    constructor(api) {
+        this.api = api;
+        this.text = new text_strategy_1.TextStrategy(api);
+        this.presence = new presence_strategy_1.PresenceStrategy(api);
+        this.image = new media_strategy_1.ImageStrategy(api);
+        this.video = new media_strategy_1.VideoStrategy(api);
+        this.audio = new media_strategy_1.AudioStrategy(api);
+        this.file = new media_strategy_1.FileStrategy(api);
+        this.voice = new voice_strategy_1.VoiceStrategy(api);
+        this.list = new list_strategy_1.ListStrategy(api);
+        this.button = new interactive_strategy_1.ButtonStrategy(api);
+        this.carousel = new interactive_strategy_1.CarouselStrategy(api);
+        this.poll = new misc_strategy_1.PollStrategy(api);
+        this.location = new misc_strategy_1.LocationStrategy(api);
+        this.reaction = new misc_strategy_1.ReactionStrategy(api);
+        this.readMessagesStrategy = new misc_strategy_1.ReadMessagesStrategy(api);
+    }
+    async dispatch(from, text, options) {
+        options = { ...options === null || options === void 0 ? void 0 : options.options };
+        if (options === null || options === void 0 ? void 0 : options.media) {
+            return this.sendMediaByType({
+                from,
+                url: options.media,
+                text,
+                delay: options.delay,
+            });
+        }
+        return this.sendText({ from, text });
+    }
+    async sendMediaByType(data) {
+        switch (data.mediaType) {
+            case "image":
+                return this.sendImage(data);
+            case "video":
+                return this.sendVideo(data);
+            case "audio":
+                return this.sendVoice(data);
+            case "document":
+                return this.sendFile(data);
+            default:
+                return this.sendText({ from: data.from, text: data.text });
+        }
+    }
+    sendText(data) {
+        return this.text.send(data);
+    }
+    sendPresence(data) {
+        return this.presence.send(data);
+    }
+    sendImage(data) {
+        return this.image.send(data);
+    }
+    sendVideo(data) {
+        return this.video.send(data);
+    }
+    sendAudio(data) {
+        return this.audio.send(data);
+    }
+    sendFile(data) {
+        return this.file.send(data);
+    }
+    sendVoice(data) {
+        return this.voice.send(data);
+    }
+    sendList(data) {
+        return this.list.send(data);
+    }
+    sendButton(data) {
+        return this.button.send(data);
+    }
+    sendCarousel(data) {
+        return this.carousel.send(data);
+    }
+    sendPoll(data) {
+        return this.poll.send(data);
+    }
+    sendLocation(data) {
+        return this.location.send(data);
+    }
+    sendReaction(data) {
+        return this.reaction.send(data);
+    }
+    sendMedia(data) {
+        return this.sendMediaByType(data);
+    }
+    readMessages(data) {
+        return this.readMessagesStrategy.send(data);
+    }
+}
+exports.MessageSenderService = MessageSenderService;

package/build/application/messaging/strategies/interactive.strategy.d.ts

@@ -0,0 +1,14 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { Button, SendButton, SendCarousel } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare function normalizeButton(button: Button | string, index: number): any;
+export declare class ButtonStrategy implements SendStrategy<SendButton> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendButton): Promise<any>;
+}
+export declare class CarouselStrategy implements SendStrategy<SendCarousel> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendCarousel): Promise<any>;
+}

package/build/application/messaging/strategies/interactive.strategy.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarouselStrategy = exports.ButtonStrategy = void 0;
+exports.normalizeButton = normalizeButton;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+function normalizeButton(button, index) {
+    if (typeof button === "string") {
+        return { type: "reply", displayText: button, id: `${index + 1}` };
+    }
+    const raw = button;
+    const { type = "reply", displayText, ...rest } = raw;
+    const base = {
+        type,
+        displayText: displayText || raw.text || "",
+        id: `${index + 1}`,
+        ...rest,
+    };
+    delete base.text;
+    delete base.body;
+    delete base.reply;
+    return base;
+}
+class ButtonStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        var _a;
+        try {
+            return await this.api.sendButtons({
+                number: data.from,
+                thumbnailUrl: data.thumbnailUrl,
+                title: data.title,
+                body: data.body,
+                description: data.description,
+                footer: data.footer,
+                buttons: data.buttons.map((button, index) => normalizeButton(button, index)),
+                delay: data.delay || 2000,
+                quoted: data.quoted,
+                everyOne: data.everyOne || false,
+                mentioned: ((_a = data.mentioned) === null || _a === void 0 ? void 0 : _a.length) ? data.mentioned : [data.from],
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendButton Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.ButtonStrategy = ButtonStrategy;
+class CarouselStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        var _a;
+        try {
+            if (!(data === null || data === void 0 ? void 0 : data.from))
+                throw new Error("sendCarousel: falta 'from'");
+            if (!Array.isArray(data.cards) || data.cards.length === 0)
+                throw new Error("sendCarousel: 'cards' debe ser un array no vacío");
+            const cards = data.cards.map((card, cardIndex) => ({
+                text: card.text,
+                thumbnailUrl: card.thumbnailUrl,
+                footerText: card.footerText,
+                buttons: (card.buttons || []).map((button, buttonIndex) => normalizeButton(button, cardIndex * 100 + buttonIndex)),
+            }));
+            return await this.api.sendCarousel({
+                number: data.from,
+                title: data.title,
+                description: data.description,
+                footer: data.footer,
+                cards,
+                delay: data.delay || 2000,
+                quoted: data.quoted,
+                everyOne: data.everyOne || false,
+                mentioned: ((_a = data.mentioned) === null || _a === void 0 ? void 0 : _a.length) ? data.mentioned : [data.from],
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendCarousel Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.CarouselStrategy = CarouselStrategy;

package/build/application/messaging/strategies/list.strategy.d.ts

@@ -0,0 +1,8 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendList } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare class ListStrategy implements SendStrategy<SendList> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendList): Promise<any>;
+}

package/build/application/messaging/strategies/list.strategy.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListStrategy = void 0;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class ListStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        var _a;
+        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) => {
+                        var _a;
+                        return ({
+                            rowId: `${i + 1}`,
+                            title: r.title || "",
+                            ...(((_a = r.description) === null || _a === void 0 ? void 0 : _a.trim())
+                                ? { description: r.description.trim() }
+                                : {}),
+                        });
+                    }),
+                }));
+            return await this.api.sendList({
+                number: data.from,
+                title,
+                description,
+                footerText,
+                buttonText: button,
+                sections,
+                delay: data.delay || 2000,
+                quoted: data.quoted,
+                everyOne: data.everyOne || false,
+                mentioned: ((_a = data.mentioned) === null || _a === void 0 ? void 0 : _a.length) ? data.mentioned : [data.from],
+            });
+        }
+        catch (err) {
+            console.error("[sendList Error]", (0, error_extractor_1.extractApiError)(err));
+        }
+    }
+}
+exports.ListStrategy = ListStrategy;

package/build/application/messaging/strategies/media.strategy.d.ts

@@ -0,0 +1,32 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendMedia } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare abstract class BaseMediaStrategy implements SendStrategy<SendMedia> {
+    protected readonly api: SendWaveApiRepository;
+    protected abstract readonly mediaType: string;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendMedia): Promise<any>;
+    protected abstract getMimeType(): string;
+    protected abstract getExtension(): string;
+    protected handleError(error: any): never;
+}
+export declare class ImageStrategy extends BaseMediaStrategy {
+    protected readonly mediaType = "image";
+    protected getMimeType(): string;
+    protected getExtension(): string;
+}
+export declare class VideoStrategy extends BaseMediaStrategy {
+    protected readonly mediaType = "video";
+    protected getMimeType(): string;
+    protected getExtension(): string;
+}
+export declare class AudioStrategy extends BaseMediaStrategy {
+    protected readonly mediaType = "audio";
+    protected getMimeType(): string;
+    protected getExtension(): string;
+}
+export declare class FileStrategy extends BaseMediaStrategy {
+    protected readonly mediaType = "document";
+    protected getMimeType(): string;
+    protected getExtension(): string;
+}

package/build/application/messaging/strategies/media.strategy.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStrategy = exports.AudioStrategy = exports.VideoStrategy = exports.ImageStrategy = exports.BaseMediaStrategy = void 0;
+const crypto_1 = require("crypto");
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class BaseMediaStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.sendMedia({
+                number: data.from,
+                mediatype: this.mediaType,
+                mimetype: this.getMimeType(),
+                fileName: data.fileName || `${(0, crypto_1.randomUUID)()}.${this.getExtension()}`,
+                media: data.url,
+                caption: data.text,
+                delay: data.delay || 0,
+            });
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    handleError(error) {
+        var _a, _b;
+        if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("exceeds limit")) {
+            console.error(`[SendMedia Error] File size validation failed: ${error.message}`);
+            throw new Error(`File too large: ${error.message}`);
+        }
+        if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 413) {
+            console.error("[SendMedia Error] Server rejected large payload");
+            throw new Error("File too large for server");
+        }
+        if (error.code === "ECONNABORTED") {
+            console.error("[SendMedia Error] Request timeout - file may be too large");
+            throw new Error("Upload timeout - file may be too large");
+        }
+        const msg = (0, error_extractor_1.extractApiError)(error);
+        console.error(`[SendMedia Error] ${msg}`);
+        throw new Error(msg);
+    }
+}
+exports.BaseMediaStrategy = BaseMediaStrategy;
+class ImageStrategy extends BaseMediaStrategy {
+    constructor() {
+        super(...arguments);
+        this.mediaType = "image";
+    }
+    getMimeType() {
+        return "image/jpeg";
+    }
+    getExtension() {
+        return "jpg";
+    }
+}
+exports.ImageStrategy = ImageStrategy;
+class VideoStrategy extends BaseMediaStrategy {
+    constructor() {
+        super(...arguments);
+        this.mediaType = "video";
+    }
+    getMimeType() {
+        return "video/mp4";
+    }
+    getExtension() {
+        return "mp4";
+    }
+}
+exports.VideoStrategy = VideoStrategy;
+class AudioStrategy extends BaseMediaStrategy {
+    constructor() {
+        super(...arguments);
+        this.mediaType = "audio";
+    }
+    getMimeType() {
+        return "audio/mpeg";
+    }
+    getExtension() {
+        return "mp3";
+    }
+}
+exports.AudioStrategy = AudioStrategy;
+class FileStrategy extends BaseMediaStrategy {
+    constructor() {
+        super(...arguments);
+        this.mediaType = "document";
+    }
+    getMimeType() {
+        return "application/octet-stream";
+    }
+    getExtension() {
+        return "bin";
+    }
+}
+exports.FileStrategy = FileStrategy;

package/build/application/messaging/strategies/misc.strategy.d.ts

@@ -0,0 +1,23 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendPoll, SendLocation, SendReaction, ReadMessage } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare class PollStrategy implements SendStrategy<SendPoll> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendPoll): Promise<any>;
+}
+export declare class LocationStrategy implements SendStrategy<SendLocation> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendLocation): Promise<any>;
+}
+export declare class ReactionStrategy implements SendStrategy<SendReaction> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendReaction): Promise<any>;
+}
+export declare class ReadMessagesStrategy implements SendStrategy<ReadMessage> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: ReadMessage): Promise<any>;
+}

package/build/application/messaging/strategies/misc.strategy.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadMessagesStrategy = exports.ReactionStrategy = exports.LocationStrategy = exports.PollStrategy = void 0;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class PollStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        var _a;
+        try {
+            return await this.api.sendPoll({
+                number: data.from,
+                name: data.poll.name,
+                selectableCount: data.poll.selectableCount || 1,
+                values: data.poll.values,
+                delay: data.delay || 2000,
+                quoted: data.quoted,
+                everyOne: data.everyOne || false,
+                mentioned: ((_a = data.mentioned) === null || _a === void 0 ? void 0 : _a.length) ? data.mentioned : [data.from],
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendPoll Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.PollStrategy = PollStrategy;
+class LocationStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.sendLocation({
+                number: data.from,
+                name: data.name,
+                address: data.address,
+                latitude: data.latitude,
+                longitude: data.longitude,
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendLocation Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.LocationStrategy = LocationStrategy;
+class ReactionStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.sendReaction({
+                key: data.key,
+                reaction: data.reaction,
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendReaction Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.ReactionStrategy = ReactionStrategy;
+class ReadMessagesStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.markMessagesAsRead({
+                readMessages: [
+                    {
+                        remoteJid: data.from,
+                        fromMe: false,
+                        id: data.messageId,
+                    },
+                ],
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[readMessage Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.ReadMessagesStrategy = ReadMessagesStrategy;

package/build/application/messaging/strategies/presence.strategy.d.ts

@@ -0,0 +1,8 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendPresence } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare class PresenceStrategy implements SendStrategy<SendPresence> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendPresence): Promise<any>;
+}

package/build/application/messaging/strategies/presence.strategy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceStrategy = void 0;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class PresenceStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.sendPresence({
+                number: data.from,
+                delay: data.delay || 2000,
+                presence: data.presence || "composing",
+            });
+        }
+        catch (error) {
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[sendPresence Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.PresenceStrategy = PresenceStrategy;

package/build/application/messaging/strategies/send-strategy.interface.d.ts

@@ -0,0 +1,4 @@
+export interface SendStrategy<T> {
+    readonly endpoint?: string;
+    send(data: T): Promise<any>;
+}

package/build/application/messaging/strategies/send-strategy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/application/messaging/strategies/text.strategy.d.ts

@@ -0,0 +1,8 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendMessage } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare class TextStrategy implements SendStrategy<SendMessage> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendMessage): Promise<any>;
+}

package/build/application/messaging/strategies/text.strategy.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextStrategy = void 0;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class TextStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        try {
+            return await this.api.sendText({
+                delay: data.delay || 2000,
+                number: data.from,
+                text: data.text,
+            });
+        }
+        catch (error) {
+            console.error(`[sendText Error] ${(0, error_extractor_1.extractApiError)(error)}`);
+        }
+    }
+}
+exports.TextStrategy = TextStrategy;

package/build/application/messaging/strategies/voice.strategy.d.ts

@@ -0,0 +1,8 @@
+import { SendWaveApiRepository } from "../../../infrastructure/persistence/sendwave-api.repository";
+import { SendMedia } from "../../../domain/types";
+import { SendStrategy } from "./send-strategy.interface";
+export declare class VoiceStrategy implements SendStrategy<SendMedia> {
+    private readonly api;
+    constructor(api: SendWaveApiRepository);
+    send(data: SendMedia): Promise<any>;
+}

package/build/application/messaging/strategies/voice.strategy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceStrategy = void 0;
+const error_extractor_1 = require("../../../shared/utils/error-extractor");
+class VoiceStrategy {
+    constructor(api) {
+        this.api = api;
+    }
+    async send(data) {
+        var _a, _b;
+        try {
+            return await this.api.sendWhatsAppAudio({
+                number: data.from,
+                audio: data.url,
+                delay: data.delay || 2000,
+            });
+        }
+        catch (error) {
+            if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("exceeds limit")) {
+                console.error(`[SendVoice Error] File size validation failed: ${error.message}`);
+                throw new Error(`Audio file too large: ${error.message}`);
+            }
+            if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 413) {
+                console.error("[SendVoice Error] Server rejected large payload");
+                throw new Error("Audio file too large for server");
+            }
+            if (error.code === "ECONNABORTED") {
+                console.error("[SendVoice Error] Request timeout - audio file may be too large");
+                throw new Error("Upload timeout - audio file may be too large");
+            }
+            const msg = (0, error_extractor_1.extractApiError)(error);
+            console.error(`[SendVoice Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
+}
+exports.VoiceStrategy = VoiceStrategy;