Message¶

import { WhatsApp, RedisEngine } from "@arcaelas/whatsapp";

// wa.Message.Text, wa.Message.Image, wa.Message.Video,
// wa.Message.Audio, wa.Message.Gps, wa.Message.Poll

import type { IMessage } from "@arcaelas/whatsapp";

new wa.Message.Text({ wa, doc });
// doc: IMessage — the persisted document from the engine.

wa.on("message:created", async (msg, chat) => {
  if (msg instanceof wa.Message.Text) {
    console.log("text:", msg.caption);
  }
  if (msg instanceof wa.Message.Image) {
    const bytes = await msg.content();
    console.log("image bytes:", bytes.length, "caption:", msg.caption);
  }
  if (msg instanceof wa.Message.Video) {
    const stream = await msg.stream();
    // pipe to S3, ffmpeg, etc.
  }
  if (msg instanceof wa.Message.Audio) {
    console.log("voice note?", msg.ptt);
  }
  if (msg instanceof wa.Message.Gps) {
    console.log("at", msg.lat, msg.lng, "live?", msg.live);
  }
  if (msg instanceof wa.Message.Poll) {
    console.log("question:", msg.caption, "opts:", msg.options);
  }
});

switch (msg.type) {
  case "text": /* ... */ break;
  case "image": /* ... */ break;
  case "video": /* ... */ break;
  case "audio": /* ... */ break;
  case "location": /* ... */ break;
  case "poll": /* ... */ break;
}

export enum MessageStatus {
  ERROR = 0,
  PENDING = 1,
  SERVER_ACK = 2,
  DELIVERED = 3,
  READ = 4,
  PLAYED = 5,
}

import type { WAMessage } from "baileys";

export type MessageType =
  | "text" | "image" | "video" | "audio" | "location" | "poll";

export interface IMessage {
  id: string;
  cid: string;
  mid: string | null;
  me: boolean;
  type: MessageType;
  author: string;
  status: MessageStatus;
  starred: boolean;
  forwarded: boolean;
  created_at: number;
  deleted_at: number | null;
  mime: string;
  caption: string;
  edited: boolean;
  raw: WAMessage;
}

const chat = await msg.chat();
await chat.typing(true);

const sender = await msg.author();
console.log(sender.name, sender.phone);

if (msg instanceof wa.Message.Image) {
  const bytes = await msg.content();
  // await uploadToS3(bytes);
}

import { createWriteStream } from "node:fs";

if (msg instanceof wa.Message.Video) {
  const src = await msg.stream();
  const dst = createWriteStream("./out.mp4");
  src.pipe(dst);
}

await msg.react("thumbs-up");
await msg.react(""); // remove

await msg.forward("5215555555555@s.whatsapp.net");

const chat = await wa.Chat.get("120363000000000000@g.us");
await msg.forward(chat!);

const contact = await wa.Contact.get("5215555555555");
await msg.forward(contact!);

if (msg.me) {
  await msg.edit("Updated content");
}

await msg.delete();      // delete for everyone
await msg.delete(false); // delete for me only

await msg.star(true);

await msg.seen();

const unsubscribe = msg.watch((updated) => {
  console.log("status ->", updated.status);
});

// later:
unsubscribe();

wa.on("message:created", async (msg, chat) => {
  if (msg instanceof wa.Message.Text && msg.caption.toLowerCase() === "ping") {
    await msg.text("pong");
  }
});

// Create a poll
const sent = await wa.Message.poll("5215555555555@s.whatsapp.net", {
  content: "What's for lunch?",
  options: [{ content: "Pizza" }, { content: "Tacos" }, { content: "Ramen" }],
});

// React to poll updates
wa.on("message:updated", (msg) => {
  if (msg instanceof wa.Message.Poll) {
    for (const opt of msg.options) {
      console.log(opt.content, "->", opt.count);
    }
  }
});

// Vote (single or multi)
if (sent instanceof wa.Message.Poll) {
  await sent.select(0);          // vote for "Pizza"
  await sent.select([0, 2]);     // only works if `multiple === true`
}

wa.on("message:updated", (msg) => {
  if (msg instanceof wa.Message.Gps && msg.live) {
    console.log("live update ->", msg.lat, msg.lng, msg.link);
  }
});

await wa.Message.location("5215555555555@s.whatsapp.net", {
  lat: 19.4326,
  lng: -99.1332,
});

import { readFileSync } from "node:fs";

// Send a voice note (default)
await wa.Message.audio(cid, readFileSync("./note.ogg"));

// Send as a regular audio file
await wa.Message.audio(cid, readFileSync("./song.mp3"), { ptt: false });

// Detect on incoming
wa.on("message:created", async (msg) => {
  if (msg instanceof wa.Message.Audio) {
    console.log(msg.ptt ? "voice note" : "audio file");
  }
});

import type { Chat, Contact } from "@arcaelas/whatsapp";

export type ForwardTarget = string | Chat | Contact;

export interface SendOptions {
  mid?: string; // quoted message id (reply)
}

export interface SendMediaOptions extends SendOptions {
  caption?: string;
}

export interface SendAudioOptions extends SendOptions {
  ptt?: boolean; // defaults to true (voice note)
}

export interface LocationOptions {
  lat: number;
  lng: number;
  live?: boolean; // reserved, not yet used on send
}

export interface PollOptions {
  content: string;                        // question
  options: Array<{ content: string }>;    // choices
}

import { WhatsApp, FileSystemEngine } from "@arcaelas/whatsapp";
import { readFileSync } from "node:fs";

const wa = new WhatsApp({
  engine: new FileSystemEngine({ path: "./.whatsapp" }),
});

await wa.connect();

const cid = "5215555555555@s.whatsapp.net";

// Basic text
const greeting = await wa.Message.text(cid, "Hello from v3!");

// Reply (mid pins the quoted message)
if (greeting) {
  await wa.Message.text(cid, "And a follow-up.", { mid: greeting.id });
}

// Media
await wa.Message.image(cid, readFileSync("./banner.png"), { caption: "Banner" });
await wa.Message.audio(cid, readFileSync("./note.ogg"), { ptt: true });

// Location
await wa.Message.location(cid, { lat: 19.4326, lng: -99.1332 });

// Poll
await wa.Message.poll(cid, {
  content: "Pick a framework",
  options: [{ content: "Next" }, { content: "Remix" }, { content: "Astro" }],
});

// CRUD on existing messages
const history = await wa.Message.list(cid, 0, 20);
for (const m of history) {
  if (m.me && !m.edited && m instanceof wa.Message.Text) {
    await wa.Message.edit(cid, m.id, `[edited] ${m.caption}`);
  }
}