@rexxhayanasi/elaina-baileys 1.2.0-rc.6 → 1.2.0-rc.7

package/lib/Utils/newslettermedia.js

@@ -1,142 +1,103 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareWAMessageMediaNewsletter = prepareWAMessageMediaNewsletter;
-exports.getWAUploadToServerNewsletter = getWAUploadToServerNewsletter;
-
-const fs = require("fs");
+const Crypto = require("crypto");
 const Boom = require("@hapi/boom");
 const { WAProto } = require("../../WAProto");
-const { 
-    MEDIA_PATH_MAP, 
-    uploadMedia, 
-    generateThumbnail, 
-    encryptedStream, 
-    getAudioDuration, 
-    getAudioWaveform, 
-    assertColor, 
-    unixTimestampSeconds 
-} = require("./index");
-const { DEFAULT_ORIGIN } = require("../Defaults");
 
 /**
- * Encode string ke Base64
+ * Upload khusus newsletter (RAW)
+ * CODE BY REXXHAYANASI REFERENCE BY WHISKEYSOCKETS 
  */
-function encodeBase64EncodedStringForUpload(str) {
-    if (!str) return "";
-    return Buffer.from(str).toString("base64");
-}
+function getWAUploadToServerNewsletter(config, refreshMediaConn) {
+    return async (buffer, uploadOpts = {}) => {
+        if (!Buffer.isBuffer(buffer)) {
+            throw new Boom("Newsletter upload expects Buffer");
+        }
 
-/**
- * Placeholder function, harus diimplementasi sesuai Baileys v6
- */
-async function getRawMediaUploadData(media, mediaType, logger) {
-    throw new Error("Implement getRawMediaUploadData sesuai Baileys v6 mu");
+        const mediaConn = await refreshMediaConn();
+        if (!mediaConn || !mediaConn.hosts?.length) {
+            throw new Boom("Failed to obtain media connection for newsletter");
+        }
+
+        const host = mediaConn.hosts[0];
+        const url = `https://${host.hostname}${host.uploadPath}`;
+
+        const res = await fetch(url, {
+            method: "POST",
+            body: buffer,
+            headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Length": buffer.length,
+            },
+            agent: config.fetchAgent,
+        });
+
+        if (!res.ok) {
+            throw new Boom(`Newsletter upload failed: ${res.status}`);
+        }
+
+        const json = await res.json();
+
+        return {
+            mediaUrl: json.url,
+            directPath: json.direct_path,
+        };
+    };
 }
 
 /**
- * Upload ke server newsletter
+ * Ambil metadata RAW newsletter
  */
-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 getRawMediaUploadDataNewsletter(buffer) {
+    const fileSha256 = Crypto.createHash("sha256").update(buffer).digest();
+    return {
+        buffer,
+        fileSha256,
+        fileLength: buffer.length,
     };
 }
 
 /**
- * Prepare WA message untuk newsletter
+ * Builder message newsletter (PTV / media)
  */
 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;
-            break;
-        }
-    }
+    const mediaType = Object.keys(message)[0];
+    if (!mediaType) throw new Boom("Invalid newsletter media");
 
-    if (!mediaType) {
-        throw new Boom("Invalid media type", { statusCode: 400 });
+    const buffer = message[mediaType];
+    if (!Buffer.isBuffer(buffer)) {
+        throw new Boom("Newsletter media must be Buffer");
     }
 
-    const uploadData = { ...message, media: message[mediaType] };
-    delete uploadData[mediaType];
+    const uploadData = await getRawMediaUploadDataNewsletter(buffer);
 
-    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 }
+    const upload = getWAUploadToServerNewsletter(
+        {
+            fetchAgent: options.fetchAgent,
+        },
+        options.refreshMediaConn
     );
 
-    await fs.promises.unlink(filePath);
+    const uploaded = await upload(buffer);
 
-    const messageObj = {};
-    messageObj[`${mediaType}Message`] = {
-        url: urls.mediaUrl,
-        directPath: urls.directPath,
-        fileSha256,
-        fileLength,
-        ...uploadData,
-        media: undefined,
+    const proto = {};
+    proto[`${mediaType}Message`] = {
+        url: uploaded.mediaUrl,
+        directPath: uploaded.directPath,
+        fileSha256: uploadData.fileSha256,
+        fileLength: uploadData.fileLength,
+        mimetype: options.mimetype,
     };
 
-    if (uploadData.ptv && mediaType === "video") {
-        messageObj.ptvMessage = messageObj.videoMessage;
-        delete messageObj.videoMessage;
+    if (mediaType === "video") {
+        proto.videoMessage.ptv = true;
     }
 
-    return WAProto.Message.fromObject(messageObj);
+    return WAProto.Message.fromObject(proto);
 }
+
+module.exports = {
+    prepareWAMessageMediaNewsletter,
+    getRawMediaUploadDataNewsletter,
+    getWAUploadToServerNewsletter,
+};

package/package.json

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