@itsliaaa/baileys 0.2.6 → 0.3.0-rc.1

package/lib/Utils/messages.js

@@ -5,7 +5,7 @@ import { promises as fs } from 'fs';
 import { proto } from '../../WAProto/index.js';
 import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, DONATE_URL, LIBRARY_NAME, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { AssociationType, ButtonHeaderType, ButtonType, CarouselCardType, ListType, ProtocolType, WAMessageStatus, WAProto } from '../Types/index.js';
-import { isPnUser, isLidUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { isLidUser, isPnUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
@@ -82,26 +82,33 @@ const assertColor = async (color) => {
         return assertedColor;
     }
 };
-// Lia@Changes 21-04-26 --- Refactor prepareWAMessageMedia function
 export const prepareWAMessageMedia = async (message, options) => {
     const logger = options.logger;
-    const mediaType = MEDIA_KEYS.find(key => key in message);
+    let mediaType;
+    for (const key of MEDIA_KEYS) {
+        if (key in message) {
+            mediaType = key;
+        }
+    }
     if (!mediaType) {
         throw new Boom('Invalid media type', { statusCode: 400 });
     }
-    const uploadData = { ...message };
-    const mediaPayload = uploadData[mediaType];
+    const uploadData = {
+        ...message,
+        media: message[mediaType]
+    };
     delete uploadData[mediaType];
     if (uploadData.image || uploadData.video) {
         uploadData.annotations = mediaAnnotation;
     }
-    const cacheableKey = typeof mediaPayload === 'object' &&
-        'url' in mediaPayload &&
-        !!mediaPayload.url &&
+    // check if cacheable + generate cache key
+    const cacheableKey = typeof uploadData.media === 'object' &&
+        'url' in uploadData.media &&
+        !!uploadData.media.url &&
         !!options.mediaCache &&
-        `${mediaType}:${mediaPayload.url}`;
+        mediaType + ':' + uploadData.media.url.toString();
     if (mediaType === 'document' && !uploadData.fileName) {
-        uploadData.fileName = LIBRARY_NAME;
+        uploadData.fileName = 'file';
     }
     if (!uploadData.mimetype) {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
@@ -112,149 +119,133 @@ export const prepareWAMessageMedia = async (message, options) => {
             logger?.debug({ cacheableKey }, 'got media cache hit');
             const obj = proto.Message.decode(mediaBuff);
             const key = `${mediaType}Message`;
-            Object.assign(obj[key], uploadData);
+            Object.assign(obj[key], { ...uploadData, media: undefined });
             return obj;
         }
     }
-    const isNewsletter = isJidNewsletter(options.jid);
-    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 && typeof uploadData.waveform === 'undefined';
-    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
-    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
-    let mediaUrl, directPath, thumbnailDirectPath, thumbnailSha256, fileSha256, fileLength, mediaKey, fileEncSha256;
-    // Lia@Changes 06-02-26 --- Add few support for sending media to newsletter (⁠≧⁠▽⁠≦⁠)
+    const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
     if (isNewsletter) {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
-        const rawData = await getRawMediaUploadData(mediaPayload, options.mediaTypeOverride || mediaType, logger);
-        fileSha256 = rawData.fileSha256;
-        fileLength = rawData.fileLength;
-        const filePath = rawData.filePath;
+        const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
         const fileSha256B64 = fileSha256.toString('base64');
-        const [uploadResult] = await Promise.all([
-            options.upload(filePath, {
-                fileEncSha256B64: fileSha256B64,
-                mediaType,
-                timeoutMs: options.mediaUploadTimeoutMs,
-                newsletter: true
-            }),
-            (async () => {
-                try {
-                    if (requiresThumbnailComputation) {
-                        const { thumbnail } = await generateThumbnail(filePath, mediaType, options);
-                        uploadData.jpegThumbnail = thumbnail;
-                    }
-                    if (requiresDurationComputation) {
-                        uploadData.seconds = await getAudioDuration(filePath);
-                    }
-                }
-                catch (error) {
-                    logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
-                }
-            })()
-        ]);
-        // todo: add more support here
-        mediaUrl = uploadResult.mediaUrl;
-        directPath = uploadResult.directPath;
-        thumbnailDirectPath = uploadResult.thumbnailDirectPath;
-        thumbnailSha256 = uploadResult.thumbnailSha256;
-        fs.unlink(filePath).catch(() => logger?.warn('failed to remove tmp file'));
-    }
-    else {
-        const encryptedData = await encryptedStream(mediaPayload, options.mediaTypeOverride || mediaType, {
-            logger,
-            saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
-            opts: options.options
+        const { mediaUrl, directPath, thumbnailDirectPath, thumbnailSha256 } = await options.upload(filePath, {
+            fileEncSha256B64: fileSha256B64,
+            mediaType: mediaType,
+            timeoutMs: options.mediaUploadTimeoutMs,
+            newsletter: isNewsletter
         });
-        mediaKey = encryptedData.mediaKey;
-        fileEncSha256 = encryptedData.fileEncSha256;
-        fileSha256 = encryptedData.fileSha256;
-        fileLength = encryptedData.fileLength;
-        const encFilePath = encryptedData.encFilePath;
-        const originalFilePath = encryptedData.originalFilePath;
-        const fileEncSha256B64 = fileEncSha256.toString('base64');
-        const [uploadResult] = await Promise.all([
-            options.upload(encFilePath, {
+        await fs.unlink(filePath);
+        const obj = WAProto.Message.fromObject({
+            // todo: add more support here
+            [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+                url: mediaUrl,
+                directPath,
+                fileSha256,
+                fileLength,
+                thumbnailDirectPath,
+                thumbnailSha256,
+                ...uploadData,
+                media: undefined
+            })
+        });
+        if (uploadData.ptv) {
+            obj.ptvMessage = obj.videoMessage;
+            delete obj.videoMessage;
+        }
+        if (obj.stickerMessage) {
+            obj.stickerMessage.stickerSentTs = Date.now();
+        }
+        if (cacheableKey) {
+            logger?.debug({ cacheableKey }, 'set cache');
+            await options.mediaCache.set(cacheableKey, 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 && typeof uploadData.waveform === 'undefined';
+    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
+    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
+    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
+        logger,
+        saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
+        opts: options.options
+    });
+    const fileEncSha256B64 = fileEncSha256.toString('base64');
+    const [{ mediaUrl, directPath }] = await Promise.all([
+        (async () => {
+            const result = await options.upload(encFilePath, {
                 fileEncSha256B64,
                 mediaType,
                 timeoutMs: options.mediaUploadTimeoutMs
-            }),
-            (async () => {
-                try {
-                    if (requiresThumbnailComputation) {
-                        const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
-                        uploadData.jpegThumbnail = thumbnail;
-                        if (!uploadData.width && originalImageDimensions) {
-                            uploadData.width = originalImageDimensions.width;
-                            uploadData.height = originalImageDimensions.height;
-                        }
-                    }
-                    if (requiresDurationComputation) {
-                        uploadData.seconds = await getAudioDuration(originalFilePath);
-                    }
-                    if (requiresWaveformProcessing) {
-                        uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
-                    }
-                    if (requiresAudioBackground) {
-                        uploadData.backgroundArgb = await assertColor(options.backgroundColor);
+            });
+            logger?.debug({ mediaType, cacheableKey }, 'uploaded media');
+            return result;
+        })(),
+        (async () => {
+            try {
+                if (requiresThumbnailComputation) {
+                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
+                    uploadData.jpegThumbnail = thumbnail;
+                    if (!uploadData.width && originalImageDimensions) {
+                        uploadData.width = originalImageDimensions.width;
+                        uploadData.height = originalImageDimensions.height;
+                        logger?.debug('set dimensions');
                     }
+                    logger?.debug('generated thumbnail');
                 }
-                catch (error) {
-                    logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
+                if (requiresDurationComputation) {
+                    uploadData.seconds = await getAudioDuration(originalFilePath);
+                    logger?.debug('computed audio duration');
                 }
-            })()
-        ]);
-        mediaUrl = uploadResult.mediaUrl;
-        directPath = uploadResult.directPath;
-        fs.unlink(encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
-        fs.unlink(originalFilePath).catch(() => logger?.warn('failed to remove tmp file'));
-    }
-    const messagePayload = {
-        url: mediaUrl,
-        directPath,
-        fileSha256,
-        fileLength,
-        ...uploadData
-    };
-    if (isNewsletter) {
-        messagePayload.thumbnailDirectPath = thumbnailDirectPath;
-        messagePayload.thumbnailSha256 = thumbnailSha256;
-    }
-    else {
-        messagePayload.mediaKey = mediaKey;
-        messagePayload.fileEncSha256 = fileEncSha256;
-        messagePayload.mediaKeyTimestamp = unixTimestampSeconds();
-    }
-    const obj = proto.Message.create({
-        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject(messagePayload)
+                if (requiresWaveformProcessing) {
+                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
+                    logger?.debug('processed waveform');
+                }
+                if (requiresAudioBackground) {
+                    uploadData.backgroundArgb = await assertColor(options.backgroundColor);
+                    logger?.debug('computed backgroundColor audio status');
+                }
+            }
+            catch (error) {
+                logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
+            }
+        })()
+    ]).finally(async () => {
+        try {
+            await fs.unlink(encFilePath);
+            if (originalFilePath) {
+                await fs.unlink(originalFilePath);
+            }
+            logger?.debug('removed tmp files');
+        }
+        catch (error) {
+            logger?.warn('failed to remove tmp file');
+        }
+    });
+    const obj = WAProto.Message.fromObject({
+        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+            url: mediaUrl,
+            directPath,
+            mediaKey,
+            fileEncSha256,
+            fileSha256,
+            fileLength,
+            mediaKeyTimestamp: unixTimestampSeconds(),
+            ...uploadData,
+            media: undefined
+        })
     });
     if (uploadData.ptv) {
         obj.ptvMessage = obj.videoMessage;
         delete obj.videoMessage;
     }
-    if (obj.stickerMessage) {
-        obj.stickerMessage.stickerSentTs = Date.now();
-    }
     if (cacheableKey) {
-        logger?.debug({ cacheableKey }, 'set cache (background)');
-        options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+        logger?.debug({ cacheableKey }, 'set cache');
+        await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
     }
     return obj;
 };
-export const prepareDisappearingMessageSettingContent = (ephemeralExpiration) => {
-    ephemeralExpiration = ephemeralExpiration || 0;
-    const content = {
-        ephemeralMessage: {
-            message: {
-                protocolMessage: {
-                    type: ProtocolType.EPHEMERAL_SETTING,
-                    ephemeralExpiration
-                }
-            }
-        }
-    };
-    return content;
-};
 // Lia@Changes 31-01-26 --- Extract product message into a standalone function so it can also be reused as the header for interactive messages
 const prepareProductMessage = async (message, options) => {
     if (!message.businessOwnerJid) {
@@ -562,13 +553,27 @@ const prepareNativeFlowButtons = (message) => {
         messageVersion: 1
     };
 };
+export const prepareDisappearingMessageSettingContent = (ephemeralExpiration) => {
+    ephemeralExpiration = ephemeralExpiration || 0;
+    const content = {
+        ephemeralMessage: {
+            message: {
+                protocolMessage: {
+                    type: WAProto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+                    ephemeralExpiration
+                }
+            }
+        }
+    };
+    return WAProto.Message.fromObject(content);
+};
 /**
  * Generate forwarded message content like WA does
  * @param message the message to forward
  * @param options.forceForward will show the message as forwarded even if it is from you
  */
 export const generateForwardMessageContent = (message, forceForward) => {
-    let content = message.message || message;
+    let content = message.message;
     if (!content) {
         throw new Boom('no content in message', { statusCode: 400 });
     }
@@ -584,24 +589,12 @@ export const generateForwardMessageContent = (message, forceForward) => {
         key = 'extendedTextMessage';
     }
     const key_ = content?.[key];
-    const contextInfo = {};
     if (score > 0) {
-        contextInfo.forwardingScore = score;
-        contextInfo.isForwarded = true;
-    }
-    // when forwarding a newsletter/channel message, add the newsletter context
-    // so the server knows where to find the original media
-    const remoteJid = message.key?.remoteJid;
-    if (remoteJid && isJidNewsletter(remoteJid)) {
-        contextInfo.forwardedNewsletterMessageInfo = {
-            newsletterJid: remoteJid,
-            serverMessageId: message.key?.server_id ? parseInt(message.key.server_id) : null,
-            newsletterName: null
-        };
-        // strip messageContextInfo (contains messageSecret etc.) as WA Web does
-        delete content.messageContextInfo;
+        key_.contextInfo = { forwardingScore: score, isForwarded: true };
+    }
+    else {
+        key_.contextInfo = {};
     }
-    key_.contextInfo = contextInfo;
     return content;
 };
 export const hasNonNullishProperty = (message, key) => {
@@ -702,25 +695,25 @@ export const generateWAMessageContent = async (message, options) => {
             throw new Boom('require atleast 1 contact', { statusCode: 400 });
         }
         if (contactLen === 1) {
-            m.contactMessage = message.contacts.contacts[0];
+            m.contactMessage = WAProto.Message.ContactMessage.create(message.contacts.contacts[0]);
         }
         else {
-            m.contactsArrayMessage = message.contacts;
+            m.contactsArrayMessage = WAProto.Message.ContactsArrayMessage.create(message.contacts);
         }
     }
     else if (hasNonNullishProperty(message, 'location')) {
-        m.locationMessage = message.location;
+        m.locationMessage = WAProto.Message.LocationMessage.create(message.location);
     }
     else if (hasNonNullishProperty(message, 'react')) {
         if (!message.react.senderTimestampMs) {
             message.react.senderTimestampMs = Date.now();
         }
-        m.reactionMessage = message.react;
+        m.reactionMessage = WAProto.Message.ReactionMessage.create(message.react);
     }
     else if (hasNonNullishProperty(message, 'delete')) {
         m.protocolMessage = {
             key: message.delete,
-            type: ProtocolType.REVOKE
+            type: WAProto.Message.ProtocolMessage.Type.REVOKE
         };
     }
     else if (hasNonNullishProperty(message, 'forward')) {
@@ -922,25 +915,6 @@ export const generateWAMessageContent = async (message, options) => {
             vote: message.pollUpdate.vote
         };
     }
-    else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
-        m.protocolMessage = {
-            type: ProtocolType.SHARE_PHONE_NUMBER
-        };
-    }
-    else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
-        m.requestPhoneNumberMessage = {};
-    }
-    else if (hasNonNullishProperty(message, 'limitSharing')) {
-        m.protocolMessage = {
-            type: ProtocolType.LIMIT_SHARING,
-            limitSharing: {
-                sharingLimited: message.limitSharing === true,
-                trigger: 1,
-                limitSharingSettingTimestamp: Date.now(),
-                initiatedByMe: true
-            }
-        };
-    }
     // Lia@Changes 01-02-26 --- Add payment invite message
     else if (hasNonNullishProperty(message, 'paymentInviteServiceType')) {
         m.paymentInviteMessage = {
@@ -992,6 +966,25 @@ export const generateWAMessageContent = async (message, options) => {
             expectedVideoCount: videoCount
         };
     }
+    else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
+        m.protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
+        };
+    }
+    else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
+        m.requestPhoneNumberMessage = {};
+    }
+    else if (hasNonNullishProperty(message, 'limitSharing')) {
+        m.protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.LIMIT_SHARING,
+            limitSharing: {
+                sharingLimited: message.limitSharing === true,
+                trigger: 1,
+                limitSharingSettingTimestamp: Date.now(),
+                initiatedByMe: true
+            }
+        };
+    }
     else {
         m = await prepareWAMessageMedia(message, options);
     }
@@ -1315,18 +1308,21 @@ export const generateWAMessageContent = async (message, options) => {
         (hasOptionalProperty(message, 'mentionAll') && message.mentionAll)) {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo.mentionedJid = message.mentions || [];
+        if (key && 'contextInfo' in key) {
+            key.contextInfo = key.contextInfo || {};
+            if (message.mentions?.length) {
+                key.contextInfo.mentionedJid = message.mentions;
+            }
+            if (message.mentionAll) {
+                key.contextInfo.nonJidMentions = 1;
+            }
         }
         else if (key) {
             key.contextInfo = {
-                mentionedJid: message.mentions || []
+                mentionedJid: message.mentions,
+                nonJidMentions: message.mentionAll ? 1 : 0
             };
         }
-        if (message.mentionAll) {
-            key.contextInfo.mentionedJid = [];
-            key.contextInfo.nonJidMentions = 1;
-        }
     }
     if (hasOptionalProperty(message, 'contextInfo') && !!message.contextInfo) {
         const messageType = Object.keys(m)[0];
@@ -1390,7 +1386,7 @@ export const generateWAMessageContent = async (message, options) => {
                 key: message.edit,
                 editedMessage: m,
                 timestampMs: Date.now(),
-                type: ProtocolType.MESSAGE_EDIT
+                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
             }
         };
     }
@@ -1400,7 +1396,7 @@ export const generateWAMessageContent = async (message, options) => {
             m.messageContextInfo.messageSecret = randomBytes(32);
         }
     }
-    return proto.Message.create(m);
+    return WAProto.Message.create(m);
 };
 export const generateWAMessageFromContent = (jid, message, options) => {
     // set timestamp to now
@@ -1408,8 +1404,8 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     if (!options.timestamp) {
         options.timestamp = Date.now();
     }
-    const messageContextInfo = message.messageContextInfo;
     const innerMessage = normalizeMessageContent(message);
+    const messageContextInfo = message.messageContextInfo;
     const key = getContentType(innerMessage);
     const timestamp = unixTimestampSeconds(options.timestamp);
     const isNewsletter = isJidNewsletter(jid);
@@ -1464,7 +1460,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         };
         messageContextInfo.deviceListMetadataVersion = 2;
     }
-    message = proto.Message.create(message);
+    message = WAProto.Message.create(message);
     const messageJSON = {
         key: {
             remoteJid: jid,
@@ -1479,14 +1475,11 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     };
     return WAProto.WebMessageInfo.fromObject(messageJSON);
 };
-export const generateWAMessage = async (jid, content, options = {}) => {
+export const generateWAMessage = async (jid, content, options) => {
     // ensure msg ID is with every log
     options.logger = options?.logger?.child({ msgId: options.messageId });
     // Pass jid in the options to generateWAMessageContent
-    if (jid && typeof options === 'object') {
-        options.jid = jid;
-    }
-    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, options), options);
+    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { ...options, jid }), options);
 };
 /** Get the key to access the true type of content */
 export const getContentType = (content) => {
@@ -1515,7 +1508,6 @@ export const normalizeMessageContent = (content) => {
         content = inner.message;
     }
     return content;
-    // Lia@Changes 03-02-26 --- Add all futureProofMessage into getFutureProofMessage()
     function getFutureProofMessage(message) {
         return (message?.associatedChildMessage ||
             message?.botForwardedMessage ||
@@ -1531,10 +1523,13 @@ export const normalizeMessageContent = (content) => {
             message?.groupStatusMessageV2 ||
             message?.limitSharingMessage ||
             message?.lottieStickerMessage ||
+            message?.newsletterAdminProfileMessage ||
+            message?.newsletterAdminProfileMessageV2 ||
             message?.pollCreationMessageV4 ||
             message?.pollCreationOptionImageMessage ||
             message?.questionMessage ||
             message?.questionReplyMessage ||
+            message?.spoilerMessage ||
             message?.statusAddYours ||
             message?.statusMentionMessage ||
             message?.viewOnceMessage ||