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

package/lib/Utils/index.js

@@ -34,3 +34,4 @@ __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

@@ -88,18 +88,13 @@ const getImageProcessingLibrary = async () => {
 const hkdfInfoKey = (type) => {
     if (type === 'sticker-pack') return 'WhatsApp Image Keys';
     if (type === 'ptv') return 'WhatsApp Video Keys';
-    
-    // Support Newsletter keys explicitly or fallback
     if (type === 'newsletter-image') return 'WhatsApp Image Keys';
     if (type === 'newsletter-video') return 'WhatsApp Video Keys';
 
     const hkdfInfo = Defaults_1.MEDIA_HKDF_KEY_MAPPING[type];
-    
-    // Fallback if type not found to prevent undefined key error
     if (!hkdfInfo) {
         return 'WhatsApp Image Keys'; 
     }
-
     return `WhatsApp ${hkdfInfo} Keys`;
 };
 exports.hkdfInfoKey = hkdfInfoKey;
@@ -770,9 +765,7 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
         const hosts = [...customUploadHosts, ...uploadInfo.hosts];
         const chunks = [];
         
-        // --- MODIFIKASI: Panggil via objek toAsyncIterable_1 ---
         try {
-            // Kita akses properti .toAsyncIterable karena diimpor sebagai objek
             stream = toAsyncIterable_1.toAsyncIterable(stream);
         } catch (error) {
              throw new boom_1.Boom(error.message, { statusCode: 400 });

package/lib/Utils/messages.js

@@ -117,8 +117,10 @@ const assertColor = async (color) => {
         media: message[mediaType] || message['ptv'] 
     };
 
+    if (!(mediaType === 'audio' && uploadData.ptt)) {
     delete uploadData[mediaType];
-    delete uploadData['ptv'];
+}
+     delete uploadData['ptv']; 
 
     const cacheableKey = typeof uploadData.media === 'object' &&
         ('url' in uploadData.media) &&
@@ -145,19 +147,20 @@ const assertColor = async (color) => {
     }
 
     const isNewsletter = options.newsletter || (options.jid && (0, WABinary_1.isJidNewsletter)(options.jid));
-
     if (isNewsletter) {
         logger === null || logger === void 0 ? void 0 : logger.debug({ key: cacheableKey }, 'Preparing raw media for newsletter');
 
-        const { bodyPath, fileSha256, fileLength, didSaveToTmpPath } = await (0, messages_media_1.prepareStream)(
+
+        const { bodyPath, fileSha256, fileLength, didSaveToTmpPath, encWriteStream } = await (0, messages_media_1.prepareStream)(
             uploadData.media,
             options.mediaTypeOverride || mediaType,
             { logger, opts: options.options }
         );
 
         const fileEncSha256B64 = fileSha256.toString('base64');
+        const streamToUpload = bodyPath || encWriteStream;
 
-        const { mediaUrl, directPath } = await options.upload(bodyPath, {
+        const { mediaUrl, directPath } = await options.upload(streamToUpload, {
             fileEncSha256B64,
             mediaType,
             timeoutMs: options.mediaUploadTimeoutMs,
@@ -183,6 +186,10 @@ const assertColor = async (color) => {
             })
         });
 
+        if (mediaType === 'audio' && uploadData.ptt) {
+    obj.audioMessage.ptt = true;
+        }
+
         if (isPtv) {
             obj.ptvMessage = obj.videoMessage;
             delete obj.videoMessage;

package/lib/Utils/newslettermedia.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const fs = require("fs");
+const Boom = require("@hapi/boom");
+const { WAProto } = require("../../WAProto");
+const { MEDIA_PATH_MAP, uploadMedia } = require("./Utils");
+const { DEFAULT_ORIGIN } = require("../Defaults");
+const { unixTimestampSeconds } = require("./generics");
+const {
+generateThumbnail,
+encryptedStream,
+getAudioDuration,
+getAudioWaveform,
+assertColor,
+} = require("./messages-media");
+
+function encodeBase64EncodedStringForUpload(str) {
+if (!str) return "";
+return Buffer.from(str).toString("base64");
+}
+
+
+async function getRawMediaUploadData(media, mediaType, logger) {
+throw new Error("Implement getRawMediaUploadData sesuai Baileys v6 mu");
+}
+
+function getWAUploadToServerNewsletter({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) {
+return async (filePath, { mediaType, fileEncSha256B64, timeoutMs }) => {
+let uploadInfo = await refreshMediaConn(false);
+let urls;
+const hosts = [...customUploadHosts, ...uploadInfo.hosts];
+
+fileEncSha256B64 = encodeBase64EncodedStringForUpload(fileEncSha256B64);  
+
+const headers = {  
+  "Content-Type": "application/octet-stream",  
+  Origin: DEFAULT_ORIGIN,  
+  ...(options?.headers || {}),  
+};  
+
+for (const { hostname } of hosts) {  
+  logger.debug(`uploading to "${hostname}"`);  
+  const auth = encodeURIComponent(uploadInfo.auth);  
+  const url = `https://${hostname}${MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;  
+
+  let result;  
+  try {  
+    result = await uploadMedia({ url, filePath, headers, timeoutMs, agent: fetchAgent }, logger);  
+
+    if (result?.url || result?.direct_path) {  
+      urls = {  
+        mediaUrl: result.url,  
+        directPath: result.direct_path,  
+        meta_hmac: result.meta_hmac,  
+        fbid: result.fbid,  
+        ts: result.ts,  
+      };  
+      break;  
+    } else {  
+      uploadInfo = await refreshMediaConn(true);  
+      throw new Error(`upload failed, reason: ${JSON.stringify(result)}`);  
+    }  
+  } catch (error) {  
+    const isLast = hostname === hosts[uploadInfo.hosts.length - 1]?.hostname;  
+    logger.warn({ trace: error?.stack, uploadResult: result }, `Error in uploading to ${hostname} ${isLast ? "" : ", retrying..."}`);  
+  }  
+}  
+
+if (!urls) throw new Boom("Media upload failed on all hosts", { statusCode: 500 });  
+return urls;
+
+};
+}
+
+async function prepareWAMessageMediaNewsletter(message, options) {
+const logger = options.logger;
+
+let mediaType;
+for (const key of Object.keys(MEDIA_PATH_MAP)) {
+if (key in message) {
+mediaType = key;
+}
+}
+if (!mediaType) {
+throw new Boom("Invalid media type", { statusCode: 400 });
+}
+
+const uploadData = {
+...message,
+media: message[mediaType],
+};
+delete uploadData[mediaType];
+
+if (mediaType === "document" && !uploadData.fileName) {
+uploadData.fileName = "file";
+}
+if (!uploadData.mimetype) {
+uploadData.mimetype = MEDIA_PATH_MAP[mediaType]?.mimetype || "application/octet-stream";
+}
+
+const isNewsletter = options.newsletter || (options.jid && options.jid.endsWith("@newsletter"));
+if (!isNewsletter) {
+throw new Boom("This function is only for newsletter", { statusCode: 400 });
+}
+
+const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(
+uploadData.media,
+mediaType,
+logger
+);
+
+const fileSha256B64 = fileSha256.toString("base64");
+
+const urls = await getWAUploadToServerNewsletter(options, options.refreshMediaConn)(
+filePath,
+{ mediaType, fileEncSha256B64: fileSha256B64, timeoutMs: options.mediaUploadTimeoutMs }
+);
+
+await fs.promises.unlink(filePath);
+
+const obj = WAProto.Message.fromObject({
+[${mediaType}Message]: {
+url: urls.mediaUrl,
+directPath: urls.directPath,
+fileSha256,
+fileLength,
+...uploadData,
+media: undefined,
+},
+});
+
+if (uploadData.ptv) {
+obj.ptvMessage = obj.videoMessage;
+delete obj.videoMessage;
+}
+
+return obj;
+}
+
+module.exports = {
+prepareWAMessageMediaNewsletter,
+getWAUploadToServerNewsletter,
+};

package/package.json

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