@gamastudio/sendwave-provider 1.0.3 → 1.0.5

package/build/infrastructure/http/axios/sendwave-api.factory.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendWaveApiFactory = void 0;
+const axios_1 = __importDefault(require("axios"));
+const https_1 = require("https");
+const size_parser_1 = require("../../../shared/utils/size-parser");
+const constants_1 = require("../../../config/constants");
+const retry_interceptor_1 = require("./retry.interceptor");
+class SendWaveApiFactory {
+    constructor(config) {
+        this.config = config;
+    }
+    create() {
+        const url = this.resolveUrl();
+        const payloadLimits = this.config.payloadLimits || {};
+        const maxContentLength = (0, size_parser_1.parseSize)(payloadLimits.json || "50mb");
+        const instance = axios_1.default.create({
+            baseURL: url,
+            httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
+            headers: {
+                "Content-Type": "application/json",
+                apikey: this.config.apiKey,
+            },
+            maxContentLength,
+            maxBodyLength: maxContentLength,
+            timeout: constants_1.API_TIMEOUT_MS,
+        });
+        instance.interceptors.request.use((config) => {
+            const contentLength = (config.headers && config.headers["content-length"]) ||
+                (config.data ? JSON.stringify(config.data).length : 0);
+            if (contentLength > constants_1.LARGE_REQUEST_THRESHOLD) {
+                console.log(`[LargeRequest] Sending ${Math.round((contentLength / 1024 / 1024) * 100) / 100}MB to ${config.url}`);
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        (0, retry_interceptor_1.attachRetryInterceptor)(instance);
+        return instance;
+    }
+    resolveUrl() {
+        var _a;
+        const candidate = (_a = this.config.url) === null || _a === void 0 ? void 0 : _a.trim();
+        if (candidate)
+            return candidate;
+        return constants_1.DEFAULT_FALLBACK_URL;
+    }
+}
+exports.SendWaveApiFactory = SendWaveApiFactory;

package/build/infrastructure/http/middleware/body-parser.middleware.d.ts

@@ -0,0 +1,2 @@
+import { GlobalVendorArgs } from "../../../domain/types";
+export declare function bodyParserMiddleware(globalVendorArgs: GlobalVendorArgs): any[];

package/build/infrastructure/http/middleware/body-parser.middleware.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyParserMiddleware = bodyParserMiddleware;
+const body_parser_1 = __importDefault(require("body-parser"));
+function bodyParserMiddleware(globalVendorArgs) {
+    const payloadLimits = globalVendorArgs.payloadLimits || {};
+    return [
+        body_parser_1.default.json({
+            limit: payloadLimits.json || "50mb",
+            type: "application/json",
+        }),
+        body_parser_1.default.urlencoded({
+            limit: payloadLimits.urlencoded || "50mb",
+            extended: true,
+        }),
+        body_parser_1.default.text({
+            limit: payloadLimits.text || "10mb",
+            type: "text/*",
+        }),
+        body_parser_1.default.raw({
+            limit: payloadLimits.json || "50mb",
+            type: "application/octet-stream",
+        }),
+    ];
+}

package/build/infrastructure/http/middleware/cors.middleware.d.ts

@@ -0,0 +1,6 @@
+import cors from "cors";
+export declare const corsMiddleware: (req: cors.CorsRequest, res: {
+    statusCode?: number | undefined;
+    setHeader(key: string, value: string): any;
+    end(): any;
+}, next: (err?: any) => any) => void;

package/build/infrastructure/http/middleware/cors.middleware.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsMiddleware = void 0;
+const cors_1 = __importDefault(require("cors"));
+exports.corsMiddleware = (0, cors_1.default)({ origin: "*", methods: "GET,POST" });

package/build/infrastructure/http/middleware/global-args.middleware.d.ts

@@ -0,0 +1,2 @@
+import { GlobalVendorArgs } from "../../../domain/types";
+export declare function globalArgsMiddleware(globalVendorArgs: GlobalVendorArgs): (req: any, _: any, next: any) => any;

package/build/infrastructure/http/middleware/global-args.middleware.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalArgsMiddleware = globalArgsMiddleware;
+function globalArgsMiddleware(globalVendorArgs) {
+    return (req, _, next) => {
+        req["globalVendorArgs"] = globalVendorArgs;
+        return next();
+    };
+}

package/build/infrastructure/http/middleware/rate-limiter.middleware.d.ts

@@ -0,0 +1,4 @@
+export declare class RateLimiterMiddleware {
+    private readonly limits;
+    handle: (req: any, res: any, next: any) => any;
+}

package/build/infrastructure/http/middleware/rate-limiter.middleware.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterMiddleware = void 0;
+const constants_1 = require("../../../config/constants");
+class RateLimiterMiddleware {
+    constructor() {
+        this.limits = new Map();
+        this.handle = (req, res, next) => {
+            var _a;
+            const ip = (req.ip ||
+                req.headers["x-forwarded-for"] ||
+                ((_a = req.connection) === null || _a === void 0 ? void 0 : _a.remoteAddress) ||
+                "unknown").toString();
+            const now = Date.now();
+            const rec = this.limits.get(ip) || { count: 0, windowStart: now };
+            if (now - rec.windowStart > constants_1.RATE_LIMIT_CONFIG.windowMs) {
+                rec.count = 0;
+                rec.windowStart = now;
+            }
+            rec.count += 1;
+            this.limits.set(ip, rec);
+            if (rec.count > constants_1.RATE_LIMIT_CONFIG.max) {
+                res.statusCode = 429;
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ error: "Too Many Requests" }));
+            }
+            next();
+        };
+    }
+}
+exports.RateLimiterMiddleware = RateLimiterMiddleware;

package/build/infrastructure/http/middleware/static-assets.middleware.d.ts

@@ -0,0 +1,2 @@
+import sirv from "sirv";
+export declare const staticAssetsMiddleware: sirv.RequestHandler;

package/build/infrastructure/http/middleware/static-assets.middleware.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticAssetsMiddleware = void 0;
+const sirv_1 = __importDefault(require("sirv"));
+exports.staticAssetsMiddleware = (0, sirv_1.default)("public/assets", { dev: true });

package/build/infrastructure/http/routes/routes.d.ts

@@ -0,0 +1,4 @@
+import { InstanceRegistry } from "../../persistence/instance.registry";
+export declare function createQrRouteHandler(registry: InstanceRegistry): (req: any, res: any) => Promise<any>;
+export declare function createConnectionStateRouteHandler(registry: InstanceRegistry): (req: any, res: any) => Promise<any>;
+export declare function createWebhookRouteHandler(vendor: any): any;

package/build/infrastructure/http/routes/routes.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQrRouteHandler = createQrRouteHandler;
+exports.createConnectionStateRouteHandler = createConnectionStateRouteHandler;
+exports.createWebhookRouteHandler = createWebhookRouteHandler;
+function createQrRouteHandler(registry) {
+    return async (req, res) => {
+        var _a, _b;
+        const instanceName = (_a = req.params) === null || _a === void 0 ? void 0 : _a.instanceName;
+        const instance = instanceName
+            ? registry.get(instanceName)
+            : registry.getDefault();
+        if (!instance) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "application/json");
+            return res.end(JSON.stringify({ error: "Instance not found" }));
+        }
+        try {
+            const response = await instance.api.getQrCode();
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify((_b = response === null || response === void 0 ? void 0 : response.data) !== null && _b !== void 0 ? _b : {}));
+        }
+        catch (err) {
+            res.statusCode = 502;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "No se pudo obtener el código de conexión" }));
+        }
+    };
+}
+function createConnectionStateRouteHandler(registry) {
+    return async (req, res) => {
+        var _a, _b;
+        const instanceName = (_a = req.params) === null || _a === void 0 ? void 0 : _a.instanceName;
+        const instance = instanceName
+            ? registry.get(instanceName)
+            : registry.getDefault();
+        if (!instance) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "application/json");
+            return res.end(JSON.stringify({ error: "Instance not found" }));
+        }
+        try {
+            const response = await instance.api.getConnectionState();
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify((_b = response === null || response === void 0 ? void 0 : response.data) !== null && _b !== void 0 ? _b : {}));
+        }
+        catch (err) {
+            res.statusCode = 502;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "No se pudo obtener el estado" }));
+        }
+    };
+}
+function createWebhookRouteHandler(vendor) {
+    return vendor.incomingMsg.bind(vendor);
+}

package/build/infrastructure/media/media-detector.service.d.ts

@@ -0,0 +1,27 @@
+import { MediaLimits } from "../../domain/types";
+export interface MediaDetectionResult {
+    media?: string;
+    mimeType?: string;
+    mediaType?: string;
+    fileName?: string;
+    size?: number;
+}
+export declare class MediaDetector {
+    static instance: MediaDetector;
+    private mediaLimits;
+    constructor(limits?: MediaLimits);
+    static getInstance(limits?: MediaLimits): MediaDetector;
+    updateLimits(limits: MediaLimits): void;
+    isRemoteUrl(url: string): boolean;
+    processMedia(input: string): Promise<MediaDetectionResult>;
+    validateUrlSize(url: string, mediaType: string): Promise<number>;
+    convertPathToBase64(filePath: string): Promise<MediaDetectionResult>;
+    getMimeTypeFromUrl(url: string): Promise<{
+        mediaType: string | null;
+        mimeType: string | null;
+    }>;
+    mapMimeToCategory(mimeType: string): "image" | "video" | "audio" | "document" | "unknown";
+    private validateSize;
+    private extractFileNameFromUrl;
+}
+export declare const mediaDetector: MediaDetector;

package/build/infrastructure/media/media-detector.service.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaDetector = exports.MediaDetector = 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"));
+const size_parser_1 = require("../../shared/utils/size-parser");
+class MediaDetector {
+    constructor(limits) {
+        this.mediaLimits = {
+            image: "10mb",
+            video: "100mb",
+            audio: "50mb",
+            document: "25mb",
+            ...limits,
+        };
+    }
+    static getInstance(limits) {
+        if (!MediaDetector.instance) {
+            MediaDetector.instance = new MediaDetector(limits);
+        }
+        return MediaDetector.instance;
+    }
+    updateLimits(limits) {
+        this.mediaLimits = { ...this.mediaLimits, ...limits };
+    }
+    isRemoteUrl(url) {
+        try {
+            const u = new URL(url);
+            return u.protocol === "http:" || u.protocol === "https:";
+        }
+        catch {
+            return false;
+        }
+    }
+    async processMedia(input) {
+        if (this.isRemoteUrl(input)) {
+            const { mediaType, mimeType } = await this.getMimeTypeFromUrl(input);
+            if (!mediaType || !mimeType)
+                throw new Error("No se pudo determinar el tipo MIME de la URL remota");
+            const size = await this.validateUrlSize(input, mediaType);
+            const fileName = this.extractFileNameFromUrl(input);
+            return { media: input, mimeType, fileName, mediaType, size };
+        }
+        return this.convertPathToBase64(input);
+    }
+    async validateUrlSize(url, mediaType) {
+        var _a;
+        try {
+            const response = await axios_1.default.head(url);
+            const contentLength = parseInt(String((_a = response.headers["content-length"]) !== null && _a !== void 0 ? _a : "0"));
+            if (contentLength > 0) {
+                this.validateSize(contentLength, mediaType);
+            }
+            return contentLength;
+        }
+        catch (error) {
+            if (error.message.includes("exceeds limit"))
+                throw error;
+            return 0;
+        }
+    }
+    async convertPathToBase64(filePath) {
+        const mimeType = mime_types_1.default.lookup(filePath).toString();
+        const mediaType = this.mapMimeToCategory(mimeType);
+        if (!mediaType)
+            throw new Error("No se pudo determinar el tipo MIME del archivo");
+        const stats = await promises_1.default.stat(filePath);
+        this.validateSize(stats.size, mediaType);
+        const fileBuffer = await promises_1.default.readFile(filePath);
+        const media = fileBuffer.toString("base64");
+        const fileName = path_1.default.basename(filePath);
+        return { media, mediaType, fileName, mimeType, size: stats.size };
+    }
+    async getMimeTypeFromUrl(url) {
+        try {
+            const res = await axios_1.default.head(url);
+            const contentType = res.headers["content-type"];
+            const contentTypeStr = contentType ? String(contentType) : null;
+            const mediaType = this.mapMimeToCategory(contentTypeStr !== null && contentTypeStr !== void 0 ? contentTypeStr : "unknown");
+            return { mediaType: mediaType || null, mimeType: contentTypeStr };
+        }
+        catch {
+            return { mediaType: null, mimeType: null };
+        }
+    }
+    mapMimeToCategory(mimeType) {
+        if (!mimeType)
+            return "unknown";
+        const normalized = mimeType.toLowerCase().split(";")[0].trim();
+        if (normalized.startsWith("image/"))
+            return "image";
+        if (normalized.startsWith("video/"))
+            return "video";
+        if (normalized.startsWith("audio/"))
+            return "audio";
+        if (normalized.startsWith("application/") ||
+            normalized.startsWith("text/")) {
+            return "document";
+        }
+        return "document";
+    }
+    validateSize(size, mediaType) {
+        const limitStr = this.mediaLimits[mediaType] || "10mb";
+        const limit = (0, size_parser_1.parseSize)(limitStr, 10 * 1024 * 1024);
+        if (size > limit) {
+            const sizeMB = Math.round((size / 1024 / 1024) * 100) / 100;
+            const limitMB = Math.round((limit / 1024 / 1024) * 100) / 100;
+            throw new Error(`File size ${sizeMB}MB exceeds limit of ${limitMB}MB for ${mediaType} files`);
+        }
+    }
+    extractFileNameFromUrl(url) {
+        const urlObj = new URL(url);
+        const name = urlObj.pathname.split("/").pop();
+        return name || `file_${Date.now()}`;
+    }
+}
+exports.MediaDetector = MediaDetector;
+exports.mediaDetector = MediaDetector.getInstance();

package/build/infrastructure/parser/incoming-message.parser.d.ts

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

package/build/infrastructure/parser/incoming-message.parser.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncomingMsg = parseIncomingMsg;
+function parseIncomingMsg(payload) {
+    var _a, _b;
+    try {
+        const msg = payload;
+        if (msg.type === "reactionMessage")
+            return null;
+        if (!msg)
+            return null;
+        const messageId = msg.messageId || "";
+        const fromMe = msg.fromMe;
+        const remoteJid = msg.remoteJid || "";
+        const from = msg.from;
+        const to = ((_a = payload.inputs) === null || _a === void 0 ? void 0 : _a.instanceName) || "";
+        const name = msg.name;
+        const body = msg.body;
+        const type = msg.type;
+        const media = msg.media;
+        const caption = msg.caption;
+        return {
+            fromMe,
+            remoteJid,
+            messageId,
+            from,
+            to,
+            name,
+            body,
+            type,
+            media,
+            caption,
+            sessionId: (_b = payload.inputs) === null || _b === void 0 ? void 0 : _b.sessionId,
+            originalPayload: payload.originalPayload,
+        };
+    }
+    catch (error) {
+        console.error("[parseIncomingMsg] Error:", error);
+        return null;
+    }
+}

package/build/infrastructure/persistence/instance.registry.d.ts

@@ -0,0 +1,21 @@
+import { GlobalVendorArgs, InstanceConfig } from "../../domain/types";
+import { SendWaveApiRepository } from "./sendwave-api.repository";
+import { MessageSenderService } from "../../application/messaging/message-sender.service";
+export interface RegisteredInstance {
+    name: string;
+    apiKey: string;
+    api: SendWaveApiRepository;
+    sender: MessageSenderService;
+}
+export declare class InstanceRegistry {
+    private readonly sharedConfig;
+    private instances;
+    constructor(sharedConfig: Partial<GlobalVendorArgs>);
+    register(config: InstanceConfig): RegisteredInstance;
+    registerMany(configs: InstanceConfig[]): void;
+    get(name: string): RegisteredInstance | undefined;
+    has(name: string): boolean;
+    getAll(): RegisteredInstance[];
+    getDefault(): RegisteredInstance | undefined;
+    get names(): string[];
+}

package/build/infrastructure/persistence/instance.registry.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceRegistry = void 0;
+const sendwave_api_repository_1 = require("./sendwave-api.repository");
+const message_sender_service_1 = require("../../application/messaging/message-sender.service");
+class InstanceRegistry {
+    constructor(sharedConfig) {
+        this.sharedConfig = sharedConfig;
+        this.instances = new Map();
+    }
+    register(config) {
+        const api = sendwave_api_repository_1.SendWaveApiRepository.forInstance(this.sharedConfig, config);
+        const sender = new message_sender_service_1.MessageSenderService(api);
+        const instance = {
+            name: config.name,
+            apiKey: config.apiKey,
+            api,
+            sender,
+        };
+        this.instances.set(config.name, instance);
+        return instance;
+    }
+    registerMany(configs) {
+        for (const config of configs) {
+            this.register(config);
+        }
+    }
+    get(name) {
+        return this.instances.get(name);
+    }
+    has(name) {
+        return this.instances.has(name);
+    }
+    getAll() {
+        return Array.from(this.instances.values());
+    }
+    getDefault() {
+        return this.getAll()[0];
+    }
+    get names() {
+        return Array.from(this.instances.keys());
+    }
+}
+exports.InstanceRegistry = InstanceRegistry;

package/build/infrastructure/persistence/sendwave-api.repository.d.ts

@@ -0,0 +1,21 @@
+import { GlobalVendorArgs, InstanceConfig } from "../../domain/types";
+import { AxiosResponse } from "axios";
+export declare class SendWaveApiRepository {
+    private readonly api;
+    private readonly instanceName;
+    constructor(globalVendorArgs: GlobalVendorArgs);
+    static forInstance(sharedConfig: Partial<GlobalVendorArgs>, instance: InstanceConfig): SendWaveApiRepository;
+    getConnectionState(): Promise<AxiosResponse>;
+    getQrCode(): Promise<AxiosResponse>;
+    sendPresence(payload: any): Promise<AxiosResponse>;
+    sendText(payload: any): Promise<AxiosResponse>;
+    sendMedia(payload: any): Promise<AxiosResponse>;
+    sendWhatsAppAudio(payload: any): Promise<AxiosResponse>;
+    sendList(payload: any): Promise<AxiosResponse>;
+    sendButtons(payload: any): Promise<AxiosResponse>;
+    sendCarousel(payload: any): Promise<AxiosResponse>;
+    sendPoll(payload: any): Promise<AxiosResponse>;
+    sendLocation(payload: any): Promise<AxiosResponse>;
+    sendReaction(payload: any): Promise<AxiosResponse>;
+    markMessagesAsRead(payload: any): Promise<AxiosResponse>;
+}

package/build/infrastructure/persistence/sendwave-api.repository.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendWaveApiRepository = void 0;
+const sendwave_api_factory_1 = require("../http/axios/sendwave-api.factory");
+class SendWaveApiRepository {
+    constructor(globalVendorArgs) {
+        const name = globalVendorArgs.name || "bot";
+        const apiKey = globalVendorArgs.apiKey || "";
+        this.api = new sendwave_api_factory_1.SendWaveApiFactory({
+            name,
+            apiKey,
+            url: globalVendorArgs.url,
+            payloadLimits: globalVendorArgs.payloadLimits,
+        }).create();
+        this.instanceName = name;
+    }
+    static forInstance(sharedConfig, instance) {
+        return new SendWaveApiRepository({
+            ...sharedConfig,
+            name: instance.name,
+            apiKey: instance.apiKey,
+        });
+    }
+    getConnectionState() {
+        return this.api.get(`/instance/connectionState/${this.instanceName}`);
+    }
+    getQrCode() {
+        return this.api.get(`/instance/connect/${this.instanceName}`);
+    }
+    sendPresence(payload) {
+        return this.api.post(`/chat/sendPresence/${this.instanceName}`, payload);
+    }
+    sendText(payload) {
+        return this.api.post(`/message/sendText/${this.instanceName}`, payload);
+    }
+    sendMedia(payload) {
+        return this.api.post(`/message/sendMedia/${this.instanceName}`, payload);
+    }
+    sendWhatsAppAudio(payload) {
+        return this.api.post(`/message/sendWhatsAppAudio/${this.instanceName}`, payload);
+    }
+    sendList(payload) {
+        return this.api.post(`/message/sendList/${this.instanceName}`, payload);
+    }
+    sendButtons(payload) {
+        return this.api.post(`/message/sendButtons/${this.instanceName}`, payload);
+    }
+    sendCarousel(payload) {
+        return this.api.post(`/message/sendCarousel/${this.instanceName}`, payload);
+    }
+    sendPoll(payload) {
+        return this.api.post(`/message/sendPoll/${this.instanceName}`, payload);
+    }
+    sendLocation(payload) {
+        return this.api.post(`/message/sendLocation/${this.instanceName}`, payload);
+    }
+    sendReaction(payload) {
+        return this.api.post(`/message/sendReaction/${this.instanceName}`, payload);
+    }
+    markMessagesAsRead(payload) {
+        return this.api.post(`/chat/markMessageAsRead/${this.instanceName}`, payload);
+    }
+}
+exports.SendWaveApiRepository = SendWaveApiRepository;