not yet

Author: mimamch

package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "^6.2.1",
+    "@whiskeysockets/baileys": "^6.5.0",
     "mime": "^3.0.0",
     "pino": "^8.11.0",
     "qrcode-terminal": "^0.12.0"

pnpm-lock.yaml

@@ -10,6 +10,7 @@ export enum CALLBACK_KEY {
   ON_DISCONNECTED = "on-disconnected",
   ON_CONNECTING = "on-connecting",
   ON_MESSAGE_UPDATED = "on-message-updated",
+  ON_PAIRING_CODE = "on-pairing-code",
 }
 
 export abstract class Messages {

src/Defaults/index.ts

@@ -14,6 +14,7 @@ import type {
   MessageReceived,
   MessageUpdated,
   StartSessionParams,
+  StartSessionWithPairingCodeParams,
 } from "../Types";
 import { CALLBACK_KEY, CREDENTIALS, Messages } from "../Defaults";
 import {
@@ -123,6 +124,106 @@ export const startSession = async (
   return startSocket();
 };
 
+export const startSessionWithPairingCode = async (
+  sessionId: string,
+  options: StartSessionWithPairingCodeParams
+): Promise<WASocket> => {
+  if (isSessionExistAndRunning(sessionId))
+    throw new WhatsappError(Messages.sessionAlreadyExist(sessionId));
+  const logger = pino({ level: "silent" });
+
+  const { version } = await fetchLatestBaileysVersion();
+  const startSocket = async () => {
+    const { state, saveCreds } = await useMultiFileAuthState(
+      path.resolve(CREDENTIALS.DIR_NAME, sessionId + CREDENTIALS.PREFIX)
+    );
+    const sock: WASocket = makeWASocket({
+      version,
+      printQRInTerminal: false,
+      auth: state,
+      logger,
+      markOnlineOnConnect: false,
+      browser: Browsers.ubuntu("Chrome"),
+    });
+    sessions.set(sessionId, { ...sock });
+    try {
+      if (!sock.authState.creds.registered) {
+        console.log("first time pairing");
+        const code = await sock.requestPairingCode(options.phoneNumber);
+        console.log(code);
+        callback.get(CALLBACK_KEY.ON_PAIRING_CODE)?.(sessionId, code);
+      }
+
+      sock.ev.process(async (events) => {
+        if (events["connection.update"]) {
+          const update = events["connection.update"];
+          const { connection, lastDisconnect } = update;
+          if (update.qr) {
+            callback.get(CALLBACK_KEY.ON_QR)?.({
+              sessionId,
+              qr: update.qr,
+            });
+          }
+          if (connection == "connecting") {
+            callback.get(CALLBACK_KEY.ON_CONNECTING)?.(sessionId);
+          }
+          if (connection === "close") {
+            const code = (lastDisconnect?.error as Boom)?.output?.statusCode;
+            let retryAttempt = retryCount.get(sessionId) ?? 0;
+            let shouldRetry;
+            if (code != DisconnectReason.loggedOut && retryAttempt < 10) {
+              shouldRetry = true;
+            }
+            if (shouldRetry) {
+              retryAttempt++;
+            }
+            if (shouldRetry) {
+              retryCount.set(sessionId, retryAttempt);
+              startSocket();
+            } else {
+              retryCount.delete(sessionId);
+              deleteSession(sessionId);
+              callback.get(CALLBACK_KEY.ON_DISCONNECTED)?.(sessionId);
+            }
+          }
+          if (connection == "open") {
+            retryCount.delete(sessionId);
+            callback.get(CALLBACK_KEY.ON_CONNECTED)?.(sessionId);
+          }
+        }
+        if (events["creds.update"]) {
+          await saveCreds();
+        }
+        if (events["messages.update"]) {
+          const msg = events["messages.update"][0];
+          const data: MessageUpdated = {
+            sessionId: sessionId,
+            messageStatus: parseMessageStatusCodeToReadable(msg.update.status!),
+            ...msg,
+          };
+          callback.get(CALLBACK_KEY.ON_MESSAGE_UPDATED)?.(sessionId, data);
+        }
+        if (events["messages.upsert"]) {
+          const msg = events["messages.upsert"]
+            .messages?.[0] as unknown as MessageReceived;
+          msg.sessionId = sessionId;
+          msg.saveImage = (path) => saveImageHandler(msg, path);
+          msg.saveVideo = (path) => saveVideoHandler(msg, path);
+          msg.saveDocument = (path) => saveDocumentHandler(msg, path);
+          callback.get(CALLBACK_KEY.ON_MESSAGE_RECEIVED)?.({
+            ...msg,
+          });
+        }
+      });
+      return sock;
+    } catch (error) {
+      // console.log("SOCKET ERROR", error);
+      return sock;
+    }
+  };
+  return startSocket();
+};
+
 /**
  * @deprecated Use startSession method instead
  */
@@ -216,3 +317,9 @@ export const onConnecting = (listener: (sessionId: string) => any) => {
 export const onMessageUpdate = (listener: (data: MessageUpdated) => any) => {
   callback.set(CALLBACK_KEY.ON_MESSAGE_UPDATED, listener);
 };
+
+export const onPairingCode = (
+  listener: (sessionId: string, code: string) => any
+) => {
+  callback.set(CALLBACK_KEY.ON_MESSAGE_UPDATED, listener);
+};

src/Socket/index.ts

@@ -49,6 +49,13 @@ export interface StartSessionParams {
   printQR: boolean;
 }
 
+export interface StartSessionWithPairingCodeParams {
+  /**
+   * Phone Number with Country Code
+   */
+  phoneNumber: string;
+}
+
 export type MessageUpdated = WAMessageUpdate & {
   sessionId: string;
   messageStatus: