@ryuu-reinzz/haruka-lib 1.0.0

package/main/index.js

@@ -0,0 +1,50 @@
+import addProperty from './socket.js';
+import useSQLiteAuthState from './sqliteAuth.js';
+
+const haruka = console.log(`
+╭──────────────────────────────────────╮
+│    @ryuu-reinzz/haruka-lib          │
+│  Small helper for WhatsApp Baileys   │
+╰──────────────────────────────────────╯
+
+Usage:
+  haruka.extendSocketBot(socket, store, smsg, baileys)
+    → extend socket with helper methods
+
+  haruka.useSQLiteAuthState()
+    → SQLite-based auth state for your bot
+
+Examples:
+  Add socket:
+   import makeWASocket, {
+     proto,
+     generateWAMessageFromContent,
+     jidDecode,
+     downloadContentFromMessage,
+     prepareWAMessageMedia,
+     generateMessageID
+   } from "baileys";
+   const conn = makeWASocket({});
+   const baileys = {
+            proto,
+            generateWAMessageFromContent,
+            jidDecode,
+            downloadContentFromMessage,
+            prepareWAMessageMedia,
+            generateMessageID
+        }
+   import haruka from "@ryuu-reinzz/haruka-lib";
+   haruka.extendSocketBot(conn, store, smsg, baileys);
+  
+  SQLite session:
+    const sessionPath = "./session"
+    if (!fs.existsSync(sessionPath)) fs.mkdirSync(sessionPath, { recursive: true });
+    const useSQLiteAuthState = haruka.useSQLiteAuthState;
+    const { state, saveCreds } = await useSQLiteAuthState(sessionPath + \"auth.db\");
+
+Made by Ryuu
+`);
+haruka.useSQLiteAuthState = useSQLiteAuthState;
+haruka.addProperty = addProperty;
+
+export default haruka;

package/main/socket.js

@@ -0,0 +1,693 @@
+import crypto from "crypto";
+import fetch from "node-fetch";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import stkPkg from 'wa-sticker-formatter';
+const { Sticker } = stkPkg;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * @param {import('baileys').WASocket} socket
+ */
+
+export default function addProperty(socket, store, smsg, baileys) {
+ const  {
+  proto,
+  generateWAMessageFromContent,
+  jidDecode,
+  downloadContentFromMessage,
+  prepareWAMessageMedia,
+  generateMessageID
+} = baileys;
+
+Object.assign(socket, {
+ sendCard: async (jid, options = {}) => {
+  const {
+    text = "",
+    footer = "",
+    cards = [],
+    quoted = null,
+    sender = jid
+  } = options
+
+  if (!cards.length) throw new Error("cards cannot be empty")
+
+  let carouselCards = []
+  const getImageMedia = async (image) => {
+  if (!image) throw new Error("Image cannot be empty")
+
+  if (typeof image === "string") {
+    return await prepareWAMessageMedia(
+      { image: { url: image } },
+      { upload: socket.waUploadToServer }
+    )
+  }
+
+  if (Buffer.isBuffer(image)) {
+    return await prepareWAMessageMedia(
+      { image },
+      { upload: socket.waUploadToServer }
+    )
+  }
+
+  if (typeof image === "object") {
+    return await prepareWAMessageMedia(
+      { image },
+      { upload: socket.waUploadToServer }
+    )
+  }
+
+  throw new Error("Format image tidak didukung")
+}
+
+  for (let i = 0; i < cards.length; i++) {
+    const item = cards[i]
+
+    let img = await getImageMedia(item.image)
+
+    carouselCards.push({
+      header: proto.Message.InteractiveMessage.Header.fromObject({
+        title: item.caption || `Card ${i + 1}`,
+        hasMediaAttachment: true,
+        ...img
+      }),
+      nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+        buttons: Array.isArray(item.buttons) ? item.buttons : []
+      }),
+      footer: proto.Message.InteractiveMessage.Footer.create({
+        text: footer
+      })
+    })
+  }
+
+  const msg = await generateWAMessageFromContent(
+    jid,
+    {
+      viewOnceMessage: {
+        message: {
+          messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2
+          },
+          interactiveMessage: proto.Message.InteractiveMessage.fromObject({
+            body: proto.Message.InteractiveMessage.Body.fromObject({
+              text
+            }),
+            carouselMessage: proto.Message.InteractiveMessage.CarouselMessage.fromObject({
+              cards: carouselCards
+            })
+          })
+        }
+      }
+    },
+    {
+      userJid: sender,
+      quoted
+    }
+  )
+
+  return await socket.relayMessage(jid, msg.message, {
+    messageId: msg.key.id
+    })
+  },
+  
+  sendSticker: async (jid, options = {}) => {
+    try {
+        if (!options.sticker)
+            throw new Error('Please enter the path or buffer of the sticker.')
+
+        const tmpDir = path.join(__dirname, './tmp')
+        if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true })
+
+        let stickerPath
+
+        if (Buffer.isBuffer(options.sticker)) {
+            stickerPath = path.join(tmpDir, `sticker_${Date.now()}.webp`)
+            fs.writeFileSync(stickerPath, options.sticker)
+        } else if (typeof options.sticker === 'string') {
+            if (!fs.existsSync(options.sticker))
+                throw new Error(`File not found: ${options.sticker}`)
+            stickerPath = options.sticker
+        } else {
+            throw new Error('Sticker format not recognized (must be buffer or file path).')
+        }
+
+        const sticker = new Sticker(stickerPath, {
+            pack: options.packname || "Made By",
+            author: options.author || "漏 饾檷廷饾櫘饾櫔饾櫔 饾檷廷饾櫄饾櫈饾櫍饾櫙饾櫙",
+            type: options.type || 'full',
+            categories: options.categories || ['馃椏'],
+            quality: options.quality || 80
+        })
+
+        const buffer = await sticker.build()
+        const result = await socket.sendMessage(jid, { sticker: buffer })
+
+        if (Buffer.isBuffer(options.sticker)) fs.unlinkSync(stickerPath)
+
+        return result
+    } catch (e) {
+        console.error('[sendSticker Error]', e)
+    }
+},
+  
+    sendButton: async (jid, content = {}, options = {}) => {
+      if (!socket.user?.id) {
+        throw new Error("User not authenticated");
+      }
+
+      const {
+        text = "",
+        caption = "",
+        title = "",
+        footer = "",
+        buttons = [],
+        hasMediaAttachment = false,
+        image = null,
+        video = null,
+        document = null,
+        mimetype = null,
+        jpegThumbnail = null,
+        location = null,
+        product = null,
+        businessOwnerJid = null,
+      } = content;
+
+      if (!Array.isArray(buttons) || buttons.length ===
+        0) {
+        throw new Error(
+          "buttons must be a non-empty array");
+      }
+
+      const interactiveButtons = [];
+
+      for (let i = 0; i < buttons.length; i++) {
+        const btn = buttons[i];
+
+        if (!btn || typeof btn !== "object") {
+          throw new Error(
+            `button[${i}] must be an object`);
+        }
+
+        if (btn.name && btn.buttonParamsJson) {
+          interactiveButtons.push(btn);
+          continue;
+        }
+
+        if (btn.id || btn.text || btn.displayText) {
+          interactiveButtons.push({
+            name: "quick_reply",
+            buttonParamsJson: JSON
+              .stringify({
+                display_text: btn
+                  .text || btn
+                  .displayText ||
+                  `Button ${i + 1}`,
+                id: btn.id ||
+                  `quick_${i + 1}`,
+              }),
+          });
+          continue;
+        }
+
+        if (btn.buttonId && btn.buttonText
+          ?.displayText) {
+          interactiveButtons.push({
+            name: "quick_reply",
+            buttonParamsJson: JSON
+              .stringify({
+                display_text: btn
+                  .buttonText
+                  .displayText,
+                id: btn.buttonId,
+              }),
+          });
+          continue;
+        }
+
+        throw new Error(
+          `button[${i}] has invalid shape`);
+      }
+
+      let messageContent = {};
+      if (image) {
+        const mediaInput = {};
+        if (Buffer.isBuffer(image)) {
+          mediaInput.image = image;
+        } else if (typeof image === "object" && image
+          .url) {
+          mediaInput.image = {
+            url: image.url
+          };
+        } else if (typeof image === "string") {
+          mediaInput.image = {
+            url: image
+          };
+        }
+
+        const preparedMedia =
+          await prepareWAMessageMedia(mediaInput, {
+            upload: socket.waUploadToServer,
+          });
+
+        messageContent.header = {
+          title: title || "",
+          hasMediaAttachment: hasMediaAttachment,
+          imageMessage: preparedMedia
+            .imageMessage,
+        };
+      } else if (video) {
+        const mediaInput = {};
+        if (Buffer.isBuffer(video)) {
+          mediaInput.video = video;
+        } else if (typeof video === "object" && video
+          .url) {
+          mediaInput.video = {
+            url: video.url
+          };
+        } else if (typeof video === "string") {
+          mediaInput.video = {
+            url: video
+          };
+        }
+
+        const preparedMedia =
+          await prepareWAMessageMedia(mediaInput, {
+            upload: socket.waUploadToServer,
+          });
+
+        messageContent.header = {
+          title: title || "",
+          hasMediaAttachment: hasMediaAttachment,
+          videoMessage: preparedMedia
+            .videoMessage,
+        };
+      } else if (document) {
+        const mediaInput = {
+          document: {}
+        };
+
+        if (Buffer.isBuffer(document)) {
+          mediaInput.document = document;
+        } else if (typeof document === "object" &&
+          document.url) {
+          mediaInput.document = {
+            url: document.url
+          };
+        } else if (typeof document === "string") {
+          mediaInput.document = {
+            url: document
+          };
+        }
+
+        if (mimetype) {
+          if (typeof mediaInput.document ===
+            "object") {
+            mediaInput.document.mimetype = mimetype;
+          }
+        }
+
+        if (jpegThumbnail) {
+          if (typeof mediaInput.document ===
+            "object") {
+            if (Buffer.isBuffer(jpegThumbnail)) {
+              mediaInput.document.jpegThumbnail =
+                jpegThumbnail;
+            } else if (typeof jpegThumbnail ===
+              "string") {
+              try {
+                const response = await fetch(
+                  jpegThumbnail);
+                const arrayBuffer =
+                  await response
+                  .arrayBuffer();
+                mediaInput.document
+                  .jpegThumbnail = Buffer
+                  .from(arrayBuffer);
+              } catch {
+              }
+            }
+          }
+        }
+
+        const preparedMedia =
+          await prepareWAMessageMedia(mediaInput, {
+            upload: socket.waUploadToServer,
+          });
+
+        messageContent.header = {
+          title: title || "",
+          hasMediaAttachment: hasMediaAttachment,
+          documentMessage: preparedMedia
+            .documentMessage,
+        };
+      } else if (location && typeof location ===
+        "object") {
+        messageContent.header = {
+          title: title || location.name ||
+            "Location",
+          hasMediaAttachment: hasMediaAttachment,
+          locationMessage: {
+            degreesLatitude: location
+              .degressLatitude || location
+              .degreesLatitude || 0,
+            degreesLongitude: location
+              .degressLongitude || location
+              .degreesLongitude || 0,
+            name: location.name || "",
+            address: location.address || "",
+          },
+        };
+      } else if (product && typeof product === "object") {
+        let productImageMessage = null;
+        if (product.productImage) {
+          const mediaInput = {};
+          if (Buffer.isBuffer(product.productImage)) {
+            mediaInput.image = product.productImage;
+          } else if (
+            typeof product.productImage ===
+            "object" &&
+            product.productImage.url
+          ) {
+            mediaInput.image = {
+              url: product.productImage.url,
+            };
+          } else if (typeof product.productImage ===
+            "string") {
+            mediaInput.image = {
+              url: product.productImage,
+            };
+          }
+
+          const preparedMedia =
+            await prepareWAMessageMedia(
+              mediaInput, {
+                upload: socket.waUploadToServer,
+              });
+          productImageMessage = preparedMedia
+            .imageMessage;
+        }
+
+        messageContent.header = {
+          title: title || product.title ||
+            "Product",
+          hasMediaAttachment: hasMediaAttachment,
+          productMessage: {
+            product: {
+              productImage: productImageMessage,
+              productId: product.productId ||
+                "",
+              title: product.title || "",
+              description: product
+                .description || "",
+              currencyCode: product
+                .currencyCode || "USD",
+              priceAmount1000: parseInt(
+                product.priceAmount1000
+              ) || 0,
+              retailerId: product
+                .retailerId || "",
+              url: product.url || "",
+              productImageCount: product
+                .productImageCount || 1,
+            },
+            businessOwnerJid: businessOwnerJid ||
+              product.businessOwnerJid || socket
+              .user.id,
+          },
+        };
+      } else if (title) {
+        messageContent.header = {
+          title: title,
+          hasMediaAttachment: false,
+        };
+      }
+
+      const hasMedia = !!(image || video || document ||
+        location || product);
+      const bodyText = hasMedia ? caption : text ||
+        caption;
+
+      if (bodyText) {
+        messageContent.body = {
+          text: bodyText
+        };
+      }
+
+      if (footer) {
+        messageContent.footer = {
+          text: footer
+        };
+      }
+
+      messageContent.nativeFlowMessage = {
+        buttons: interactiveButtons,
+      };
+
+      const payload = proto.Message.InteractiveMessage
+        .create(messageContent);
+
+      const msg = generateWAMessageFromContent(
+        jid, {
+          viewOnceMessage: {
+            message: {
+              interactiveMessage: payload,
+            },
+          },
+        }, {
+          userJid: socket.user.id,
+          quoted: options?.quoted || null,
+        }
+      );
+      const isGroup = jid.endsWith("@g.us");
+      const additionalNodes = [{
+        tag: "biz",
+        attrs: {},
+        content: [{
+          tag: "interactive",
+          attrs: {
+            type: "native_flow",
+            v: "1",
+          },
+          content: [{
+            tag: "native_flow",
+            attrs: {
+              v: "9",
+              name: "mixed",
+            },
+          }, ],
+        }, ],
+      }, ];
+
+      if (!isGroup) {
+        additionalNodes.push({
+          tag: "bot",
+          attrs: {
+            biz_bot: "1"
+          },
+        });
+      }
+
+      await socket.relayMessage(jid, msg.message, {
+        messageId: msg.key.id,
+        additionalNodes,
+      });
+
+      return msg;
+    },
+        sendAlbum: {
+            async value(jid, items = [], options = {}) {
+                if (!this.user?.id) {
+                    throw new Error("User not authenticated");
+                }
+                
+                const messageSecret = new Uint8Array(32);
+                crypto.getRandomValues(messageSecret);
+                
+                const messageContent = {
+                    messageContextInfo: { messageSecret },
+                    albumMessage: {
+                        expectedImageCount: items.filter((a) =>
+                            a?.image).length,
+                        expectedVideoCount: items.filter((a) =>
+                            a?.video).length,
+                    },
+                };
+                
+                const generationOptions = {
+                    userJid: this.user.id,
+                    upload: this.waUploadToServer,
+                    quoted: options?.quoted || null,
+                    ephemeralExpiration: options?.quoted
+                        ?.expiration ?? 0,
+                };
+                
+                const album = generateWAMessageFromContent(jid,
+                    messageContent, generationOptions);
+                
+                await this.relayMessage(album.key.remoteJid, album
+                    .message, {
+                        messageId: album.key.id,
+                    });
+                
+                await Promise.all(
+                    items.map(async (content) => {
+                        const mediaSecret =
+                            new Uint8Array(32);
+                        crypto.getRandomValues(
+                            mediaSecret);
+                        
+                        const mediaMsg =
+                            await generateWAMessage(
+                                album.key.remoteJid,
+                                content, {
+                                    upload: this
+                                        .waUploadToServer,
+                                    ephemeralExpiration: options
+                                        ?.quoted
+                                        ?.expiration ??
+                                        0,
+                                });
+                        
+                        mediaMsg.message
+                            .messageContextInfo = {
+                                messageSecret: mediaSecret,
+                                messageAssociation: {
+                                    associationType: 1,
+                                    parentMessageKey: album
+                                        .key,
+                                },
+                            };
+                        
+                        return this.relayMessage(
+                            mediaMsg.key.remoteJid,
+                            mediaMsg.message, {
+                                messageId: mediaMsg
+                                    .key.id,
+                            });
+                    })
+                );
+                
+                return album;
+            }
+        },
+
+    sendOrder: async (jid, orderData, options = {}) => {
+      if (!socket.user?.id) {
+        throw new Error("User not authenticated");
+      }
+
+      let thumbnail = null;
+      if (orderData.thumbnail) {
+        if (Buffer.isBuffer(orderData.thumbnail)) {
+          thumbnail = orderData.thumbnail;
+        } else if (typeof orderData.thumbnail === "string") {
+          try {
+            if (orderData.thumbnail.startsWith("http")) {
+              const response = await fetch(orderData.thumbnail);
+              const arrayBuffer = await response.arrayBuffer();
+              thumbnail = Buffer.from(arrayBuffer);
+            } else {
+              thumbnail = Buffer.from(orderData.thumbnail, "base64");
+            }
+          } catch (e) {
+            socket.logger?.warn(
+              {
+                err: e.message
+              },
+              "Failed to fetch/convert thumbnail"
+            );
+            thumbnail = null;
+          }
+        }
+      }
+
+      const orderMessage = proto.Message.OrderMessage.fromObject({
+        orderId: orderData.orderId || generateMessageID(),
+        thumbnail: thumbnail,
+        itemCount: orderData.itemCount || 1,
+        status: orderData.status || proto.Message.OrderMessage.OrderStatus.INQUIRY,
+        surface: orderData.surface || proto.Message.OrderMessage.OrderSurface.CATALOG,
+        message: orderData.message || "",
+        orderTitle: orderData.orderTitle || "Order",
+        sellerJid: orderData.sellerJid || socket.user.id,
+        token: orderData.token || "",
+        totalAmount1000: orderData.totalAmount1000 || 0,
+        totalCurrencyCode: orderData.totalCurrencyCode || "IDR",
+        contextInfo: {
+          ...(options.contextInfo || {}),
+          ...(options.mentions ?
+            {
+              mentionedJid: options.mentions,
+            } :
+            {}),
+        },
+      });
+
+      const msg = proto.Message.create({
+        orderMessage,
+      });
+
+      const message = generateWAMessageFromContent(jid, msg, {
+        userJid: socket.user.id,
+        timestamp: options.timestamp || new Date(),
+        quoted: options.quoted || null,
+        ephemeralExpiration: options.ephemeralExpiration || 0,
+        messageId: options.messageId || null,
+      });
+
+      return await socket.relayMessage(message.key.remoteJid, message.message, {
+        messageId: message.key.id,
+      });
+    },
+
+    getPNFromLid: async (m, lidInput) => {
+    if (!lidInput) throw new Error("Misssing input");
+      try {
+        let chat = m.chat
+        if (chat.endsWith('@g.us')) {
+
+        const metadata = await socket.groupMetadata(chat);
+        if (!metadata || !metadata.participants) return lidInput;
+
+        const found = metadata.participants.find(entry => entry.id === lidInput);
+        return found ? found.phoneNumber : lidInput;
+        } else {
+         const { remoteJid, remoteJidAlt } = m.key
+          if (remoteJid === lidInput && remoteJidAlt.endsWith("@s.whatsapp.net")) {
+        return remoteJidAlt
+          }
+        }
+      } catch (e) {
+        console.error('Gagal ambil group metadata:', e.message);
+        return lidInput;
+      }
+    },
+
+    getLidFromPN: async (m, jidInput) => {
+    if (!jidInput) throw new Error("Misssing jid input");
+      try {
+        let chat = m.chat;
+        if (chat.endsWith('@g.us')) {
+        const metadata = await socket.groupMetadata(chat);
+        if (!metadata || !metadata.participants) return jidInput;
+
+        const found = metadata.participants.find(entry => entry.phoneNumber === jidInput);
+        return found ? found.id : jidInput;
+      } else {
+      const { remoteJid, remoteJidAlt } = m.key
+       if (!remoteJid || !remoteJidAlt) return null
+       if (remoteJidAlt === jidInput && remoteJid.endsWith("@lid")) {
+        return remoteJid
+          }
+        }      
+      } catch (e) {
+        console.error('Gagal ambil group metadata:', e.message);
+        return jidInput;
+      }      
+    },
+  });
+ };

package/main/sqliteAuth.js

@@ -0,0 +1,110 @@
+/**
+ * Custom SQLite Auth Store untuk Baileys
+ * by Ryuu
+ */
+
+//import Database from "bun:sqlite"; 
+//jika menggunakan bun runtime
+import Database from "better-sqlite3";
+/**
+ * Membuat atau mengambil auth state dari SQLite
+ * @param {string} dbPath - Lokasi file SQLite (contoh: "./auth.db")
+ */
+export async function useSQLiteAuthState(dbPath = "./auth.db", baileys) {
+  const { proto, BufferJSON, initAuthCreds } = baileys;
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL"); 
+
+  db.prepare(`
+    CREATE TABLE IF NOT EXISTS baileys_state (
+      key TEXT PRIMARY KEY,
+      value BLOB
+    )
+  `).run();
+
+  const load = (key) => {
+  const row = db.prepare("SELECT value FROM baileys_state WHERE key = ?").get(key);
+  if (!row) return null;
+  try {
+    return JSON.parse(row.value.toString(), BufferJSON.reviver);
+  } catch {
+    return null;
+  }
+};
+
+const save = (key, data) => {
+  const json = JSON.stringify(data, BufferJSON.replacer);
+  const buf = Buffer.from(json, "utf8");
+  db.prepare("REPLACE INTO baileys_state (key, value) VALUES (?, ?)").run(key, buf);
+};
+
+  const creds = load("creds") || initAuthCreds();
+
+  const keys = {};
+  const categories = [
+    "pre-key",
+    "session",
+    "sender-key",
+    "app-state-sync-key",
+    "app-state-sync-version"
+  ];
+
+  for (const category of categories) {
+    keys[category] = {};
+    const rows = db
+      .prepare("SELECT key, value FROM baileys_state WHERE key LIKE ?")
+      .all(`${category}:%`);
+    for (const row of rows) {
+      try {
+        keys[category][row.key.slice(category.length + 1)] = JSON.parse(row.value.toString());
+      } catch {}
+    }
+  }
+
+  async function saveCreds() {
+    save("creds", creds);
+  }
+
+  const set = (category, id, value) => {
+    const key = `${category}:${id}`;
+    save(key, value);
+  };
+
+  const get = (category, id) => {
+    const key = `${category}:${id}`;
+    return load(key);
+  };
+
+  const del = (category, id) => {
+    const key = `${category}:${id}`;
+    db.prepare("DELETE FROM baileys_state WHERE key = ?").run(key);
+  };
+
+  return {
+  state: {
+    creds,
+    keys: {
+      get: async (type, ids) => {
+        const data = {};
+        for (const id of ids) {
+          const value = load(`${type}:${id}`);
+          if (value) data[id] = value;
+        }
+        return data;
+      },
+      set: async (data) => {
+        for (const category in data) {
+          for (const id in data[category]) {
+            const value = data[category][id];
+            save(`${category}:${id}`, value);
+          }
+        }
+      }
+    }
+  },
+  saveCreds: async () => save("creds", creds)
+    };
+    setInterval(async () => {
+  await save("creds", creds);
+}, 30_000);
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ryuu-reinzz/haruka-lib",
+  "version": "1.0.0",
+  "description": "Library extra for bot WhatsApp",
+  "main": "main/index.js",
+  "type": "module",
+  "author": "RyuuReinzz",
+  "license": "MIT",
+  "keywords": [
+    "whatsapp-bot",
+    "baileys",
+    "haruka",
+    "nodejs",
+    "ryuu-kun",
+    ":v"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.5.0",
+    "node-fetch": "^2.6.1",
+    "wa-sticker-formatter": "^4.4.4"
+  }
+}