@rexxhayanasi/elaina-baileys 1.2.0 → 1.2.1-rc.2

package/lib/Utils/index.js

@@ -34,4 +34,3 @@ __exportStar(require("./process-message"), exports);
 __exportStar(require("./message-retry-manager"), exports);
 __exportStar(require("./browser-utils"), exports);
 __exportStar(require("./resolveJid"), exports);
-__exportStar(require("./newslettermedia"), exports);

package/lib/Utils/messages-media.js

@@ -76,7 +76,7 @@ const getImageProcessingLibrary = async () => {
     if (sharp) {
         return { sharp };
     }
-    const jimp = (_jimp === null || _jimp === void 0 ? void 0 : _jimp.default) || _jimp;
+  const jimp = (_jimp === null || _jimp === void 0 ? void 0 : _jimp.default) || _jimp;
     if (jimp) {
         return { jimp };
     }
@@ -87,6 +87,53 @@ const hkdfInfoKey = (type) => {
     return `WhatsApp ${hkdfInfo} Keys`;
 };
 exports.hkdfInfoKey = hkdfInfoKey;
+
+const getRawMediaUploadData = async (media, mediaType, logger) => {
+    
+    const { stream } = await exports.getStream(media);
+    logger === null || logger === void 0 ? void 0 : logger.debug('got stream for raw upload');
+    const hasher = Crypto.createHash('sha256'); 
+    
+    // Generate file temp
+    const filePath = (0, path_1.join)((0, os_1.tmpdir)(), mediaType + (0, generics_1.generateMessageIDV2)());
+    const fileWriteStream = (0, fs_1.createWriteStream)(filePath);
+    
+    let fileLength = 0;
+    try {
+        for await (const data of stream) {
+            fileLength += data.length;
+            hasher.update(data);
+            // Handle backpressure
+            if (!fileWriteStream.write(data)) {
+                await (0, events_1.once)(fileWriteStream, 'drain');
+            }
+        }
+        fileWriteStream.end();
+        await (0, events_1.once)(fileWriteStream, 'finish');
+        stream.destroy();
+        
+        const fileSha256 = hasher.digest();
+        logger === null || logger === void 0 ? void 0 : logger.debug('hashed data for raw upload');
+        
+        return {
+            filePath: filePath,
+            fileSha256,
+            fileLength
+        };
+    }
+    catch (error) {
+        fileWriteStream.destroy();
+        stream.destroy();
+        try {
+            await fs_1.promises.unlink(filePath);
+        }
+        catch (_a) {
+            // ignore
+        }
+        throw error;
+    }
+};
+exports.getRawMediaUploadData = getRawMediaUploadData;
 /** generates all the keys required to encrypt/decrypt & sign a media message */
 async function getMediaKeys(buffer, mediaType) {
     if (!buffer) {
@@ -874,6 +921,3 @@ const MEDIA_RETRY_STATUS_MAP = {
     [WAProto_1.proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [WAProto_1.proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418,
 };
-function __importStar(arg0) {
-    throw new Error('Function not implemented.');
-}

package/lib/Utils/messages.js

@@ -82,20 +82,20 @@ const prepareWAMessageMedia = async (message, options) => {
         media: message[mediaType]
     };
     delete uploadData[mediaType];
-    // check if cacheable + generate cache key
+    
+    // Check cache
     const cacheableKey = typeof uploadData.media === 'object' &&
         ('url' in uploadData.media) &&
         !!uploadData.media.url &&
-        !!options.mediaCache && (
-    // generate the key
-    mediaType + ':' + uploadData.media.url.toString());
+        !!options.mediaCache && (mediaType + ':' + uploadData.media.url.toString());
+        
     if (mediaType === 'document' && !uploadData.fileName) {
         uploadData.fileName = 'file';
     }
     if (!uploadData.mimetype) {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
     }
-    // check for cache hit
+    
     if (cacheableKey) {
         const mediaBuff = options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -106,19 +106,96 @@ const prepareWAMessageMedia = async (message, options) => {
             return obj;
         }
     }
+
+const isNewsletter = !!options.jid && (0, WABinary_1.isJidNewsletter)(options.jid);
+
+if (isNewsletter) {
+    logger === null || logger === void 0 ? void 0 : logger.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
+
+    const { filePath, fileSha256, fileLength } = await (0, messages_media_1.getRawMediaUploadData)(
+        uploadData.media,
+        options.mediaTypeOverride || mediaType,
+        logger
+    );
+
+    const fileSha256B64 = fileSha256.toString('base64');
+
+    try {
+        if (mediaType === 'video' || mediaType === 'image') {
+            const { thumbnail, originalImageDimensions } = await (0, messages_media_1.generateThumbnail)(filePath, mediaType, options);
+            uploadData.jpegThumbnail = thumbnail;
+
+            if (!uploadData.width && originalImageDimensions) {
+                uploadData.width = originalImageDimensions.width;
+                uploadData.height = originalImageDimensions.height;
+            }
+        }
+
+        if (mediaType === 'audio' || mediaType === 'video') {
+            if (typeof uploadData.seconds === 'undefined') {
+                uploadData.seconds = await (0, messages_media_1.getAudioDuration)(filePath);
+            }
+        }
+
+        if (mediaType === 'audio' && uploadData.ptt === true) {
+            uploadData.waveform = await (0, messages_media_1.getAudioWaveform)(filePath, logger);
+        }
+    } catch (err) {
+        logger === null || logger === void 0 ? void 0 : logger.warn({ trace: err.stack }, 'Failed to generate metadata for newsletter media');
+    }
+
+    const streamToUpload = (0, fs_1.createReadStream)(filePath);
+
+    const { mediaUrl, directPath } = await options.upload(streamToUpload, {
+        fileEncSha256B64: fileSha256B64,
+        mediaType: mediaType,
+        timeoutMs: options.mediaUploadTimeoutMs
+    });
+
+    await fs_1.promises.unlink(filePath);
+
+    const obj = Types_1.WAProto.Message.fromObject({
+        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+            url: mediaUrl,
+            directPath,
+            fileSha256,
+            fileLength,
+            ...uploadData,
+            media: undefined
+        })
+    });
+
+    if (uploadData.ptv) {
+        obj.ptvMessage = obj.videoMessage;
+        delete obj.videoMessage;
+    }
+
+    if (obj.stickerMessage) {
+        obj.stickerMessage.stickerSentTs = Date.now();
+    }
+
+    if (cacheableKey) {
+        logger === null || logger === void 0 ? void 0 : logger.debug({ cacheableKey }, 'set cache');
+        options.mediaCache.set(cacheableKey, Types_1.WAProto.Message.encode(obj).finish());
+    }
+
+    return obj;
+}
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') &&
         (typeof uploadData['jpegThumbnail'] === 'undefined');
     const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
-    const { mediaKey, encWriteStream, bodyPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath, } = await (options.newsletter ? messages_media_1.prepareStream : messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
+    
+    const { mediaKey, encWriteStream, bodyPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath, } = await (0, messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
         opts: options.options
     });
-    // url safe Base64 encode the SHA256 hash of the body
-    const fileEncSha256B64 = (options.newsletter ? fileSha256 : fileEncSha256 !== null && fileEncSha256 !== void 0 ? fileEncSha256 : fileSha256).toString('base64');
+    
+    const fileEncSha256B64 = (fileEncSha256 !== null && fileEncSha256 !== void 0 ? fileEncSha256 : fileSha256).toString('base64');
+    
     const [{ mediaUrl, directPath, handle }] = await Promise.all([
         (async () => {
             const result = await options.upload(encWriteStream, { fileEncSha256B64, mediaType, timeoutMs: options.mediaUploadTimeoutMs });
@@ -159,7 +236,7 @@ const prepareWAMessageMedia = async (message, options) => {
         if (!Buffer.isBuffer(encWriteStream)) {
             encWriteStream.destroy();
         }
-        // remove tmp files
+        
         if (didSaveToTmpPath && bodyPath) {
             try {
                 await fs_1.promises.access(bodyPath);
@@ -171,6 +248,7 @@ const prepareWAMessageMedia = async (message, options) => {
             }
         }
     });
+    
     const obj = Types_1.WAProto.Message.fromObject({
         [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
             url: handle ? undefined : mediaUrl,
@@ -184,10 +262,12 @@ const prepareWAMessageMedia = async (message, options) => {
             media: undefined
         })
     });
+    
     if (uploadData.ptv) {
         obj.ptvMessage = obj.videoMessage;
         delete obj.videoMessage;
     }
+    
     if (cacheableKey) {
         logger === null || logger === void 0 ? void 0 : logger.debug({ cacheableKey }, 'set cache');
         options.mediaCache.set(cacheableKey, Types_1.WAProto.Message.encode(obj).finish());
@@ -221,7 +301,7 @@ const generateForwardMessageContent = (message, forceForward) => {
     if (!content) {
         throw new boom_1.Boom('no content in message', { statusCode: 400 });
     }
-    // hacky copy
+    
     content = (0, exports.normalizeMessageContent)(content);
     content = WAProto_1.proto.Message.decode(WAProto_1.proto.Message.encode(content).finish());
     let key = Object.keys(content)[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexxhayanasi/elaina-baileys",
-  "version": "1.2.0",
+  "version": "1.2.1-rc.2",
   "description": "Custom Baileys WhatsApp API",
   "keywords": [
     "baileys", 

package/lib/Utils/newslettermedia.js

@@ -1,110 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWAUploadToServerNewsletter = exports.prepareWAMessageMediaNewsletter = exports.getRawMediaUploadDataNewsletter = void 0;
-
-const crypto_1 = require("crypto");
-const boom_1 = require("@hapi/boom");
-const WAProto_1 = require("../../WAProto");
-const axios_1 = require("axios");
-const Defaults_1 = require("../Defaults");
-
-function getRawMediaUploadDataNewsletter(buffer) {
-    if (!Buffer.isBuffer(buffer)) {
-        throw new boom_1.Boom("Newsletter media must be Buffer");
-    }
-    const fileSha256 = (0, crypto_1.createHash)("sha256").update(buffer).digest();
-    return {
-        buffer,
-        fileSha256,
-        fileLength: buffer.length
-    };
-}
-exports.getRawMediaUploadDataNewsletter = getRawMediaUploadDataNewsletter;
-
-function getWAUploadToServerNewsletter({ customUploadHosts = [], fetchAgent, logger, options = {} }, refreshMediaConn) {
-    return async (buffer, { mediaType, fileEncSha256B64 }) => {
-        if (!Buffer.isBuffer(buffer)) {
-            throw new boom_1.Boom("Upload expects Buffer");
-        }
-        let uploadInfo = await refreshMediaConn(false);
-        const hosts = [...customUploadHosts, ...uploadInfo.hosts];
-        let urls;
-        for (const { hostname, maxContentLengthBytes } of hosts) {
-            const auth = encodeURIComponent(uploadInfo.auth);
-            let mediaPath = Defaults_1.MEDIA_PATH_MAP[mediaType];
-            if (!mediaPath) {
-                mediaPath = "/newsletter/newsletter-image";
-            } else {
-                mediaPath = mediaPath.replace("/mms/", "/newsletter/newsletter-");
-            }
-            const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
-            try {
-                if (maxContentLengthBytes && buffer.length > maxContentLengthBytes) {
-                    throw new boom_1.Boom("Body too large", { statusCode: 413 });
-                }
-                const res = await axios_1.default.post(url, buffer, {
-                    ...options,
-                    headers: {
-                        "Content-Type": "application/octet-stream",
-                        Origin: Defaults_1.DEFAULT_ORIGIN,
-                        ...(options.headers || {})
-                    },
-                    httpsAgent: fetchAgent,
-                    responseType: "json",
-                    maxBodyLength: Infinity,
-                    maxContentLength: Infinity
-                });
-                const result = res.data;
-                if (result?.url || result?.direct_path) {
-                    urls = {
-                        mediaUrl: result.url,
-                        directPath: result.direct_path
-                    };
-                    break;
-                }
-                uploadInfo = await refreshMediaConn(true);
-            } catch (err) {
-                logger?.warn?.({ err }, `Newsletter upload failed on ${hostname}`);
-            }
-        }
-        if (!urls) {
-            throw new boom_1.Boom("Newsletter media upload failed", { statusCode: 500 });
-        }
-        return urls;
-    };
-}
-exports.getWAUploadToServerNewsletter = getWAUploadToServerNewsletter;
-
-async function prepareWAMessageMediaNewsletter(message, options) {
-    if (!options || typeof options.upload !== "function") {
-        throw new boom_1.Boom("upload function is required");
-    }
-    const mediaType = Object.keys(message || {})[0];
-    if (!mediaType) {
-        throw new boom_1.Boom("Invalid newsletter media");
-    }
-    const buffer = message[mediaType];
-    if (!Buffer.isBuffer(buffer)) {
-        throw new boom_1.Boom("Newsletter media must be Buffer");
-    }
-    const uploadData = getRawMediaUploadDataNewsletter(buffer);
-    const uploaded = await options.upload(buffer, {
-        mediaType,
-        fileEncSha256B64: uploadData.fileSha256.toString("base64"),
-        newsletter: true
-    });
-    const proto = {};
-    proto[`${mediaType}Message`] = {
-        url: uploaded.mediaUrl,
-        directPath: uploaded.directPath,
-        fileSha256: uploadData.fileSha256,
-        fileLength: uploadData.fileLength,
-        mimetype: options.mimetype
-    };
-    if (mediaType === "video") {
-        proto.videoMessage.ptv = true;
-    }
-    return WAProto_1.WAProto.Message.fromObject(proto);
-}
-exports.prepareWAMessageMediaNewsletter = prepareWAMessageMediaNewsletter;