Error in client.getChats()

[punit-mistry]

Is there an existing issue for this?

• I have searched the existing issues

Describe the bug

hey
i am try to make the whatsapp clone so after the scanning the qrcode i am getting all the contact using the client.getChats() after that i am fetching all the messages but after scanning i am getting
Error retrieving chat history: Error: Evaluation failed: TypeError: Cannot read properties of undefined (reading 'getChats')

Expected behavior

as a user i am expecting to get all the contact number and name but i am getting this Error retrieving chat history: Error: Evaluation failed: TypeError: Cannot read properties of undefined (reading 'getChats')

Steps to Reproduce the Bug or Issue

1. scanning the qrcode using the /qrcode
2. getting all the contacts
3. Error retrieving chat history: Error: Evaluation failed: TypeError: Cannot read properties of undefined (reading 'getChats')

Relevant Code

const client = new Client({
    authStrategy: new LocalAuth()
});
 

let isWhatsAppReady = false;

app.get('/qrcode', async (req, res) => {
  if (!isWhatsAppReady) {
    let qrData = '';

    // Create a promise to wait for the QR code generation
    const waitForQRCode = new Promise((resolve) => {
      // Generate and display the QR code in the terminal
      client.on('qr', (qr) => {
        console.log(qr);
        qrData = qr;
        qrcode.generate(qr, { small: true });
        
        // Resolve the promise once the QR code is generated
        resolve();
      });
    });

    // Listen for the 'authenticated' event to know when WhatsApp is ready
// Listen for the 'authenticated' event to know when WhatsApp is ready
client.on('authenticated', (session) => {
  console.log('WhatsApp authenticated');
  isWhatsAppReady = true; // Set WhatsApp as ready when authenticated
});

// Initialize the WhatsApp client
client.initialize();

    // Wait for the QR code to be generated before sending the response
    await waitForQRCode;

    // Respond with QR code data as JSON
    res.json({ qrCodeData: qrData });
  } else {
    res.send(`
      <div class="flex gap-5">
        <input
          type="text"
          className="w-60 border-2 border-black h-10 p-2 rounded-lg"
          placeholder="Send WhatsApp Message.."
          id="messageInput"
        />
        <button
          className="bg-green-600 p-2 rounded-lg text-white font-bold"
          id="sendMessageButton"
        >
          💬 Send Message
        </button>
      </div>
    `);
  }
});

app.get('/chat/messages/:username', async (req, res) => {
  if (isWhatsAppReady) {
    try {
      const { username } = req.params;

      // Find the chat by username
      const chat = await client.getChatById(username);

      // Check if the chat exists
      if (chat) {
        // Define search options to retrieve messages
        const searchOptions = {
          limit: 10, // Number of messages to retrieve (adjust as needed)
        };

        // Fetch messages from the chat
        const messages = await chat.fetchMessages(searchOptions);

        // Extract relevant message information
        const messageData = messages.map((message) => ({
          id: message.id.id,
          content: message.body,
          timestamp: message.timestamp,
          FromMe:message.id.fromMe
        }));

        res.json(messageData);
      } else {
        res.status(404).send('Chat not found');
      }
    } catch (error) {
      console.error('Error retrieving chat messages:', error);
      res.status(500).send('Error retrieving chat messages.');
    }
  } else {
    res.status(400).send('WhatsApp is not yet ready.');
  }
});


app.post('/send-message', async (req, res) => {
  const { message,DriverNumber } = req.body;
console.log(message,DriverNumber)
  if (isWhatsAppReady) {
    try {
      await client.sendMessage(DriverNumber,message);
      res.send('Message sent successfully!');
    } catch (error) {
      console.error('Error sending message:', error);
      res.status(500).send('Error sending message.');
    }
  } else {
    res.status(400).send('WhatsApp is not yet ready.');
  }
});


// Define an API endpoint for retrieving the entire chat history
app.get('/chat/history', async (req, res) => {
  try {
    // Check if WhatsApp is ready
    if (isWhatsAppReady) {
      const chats = await client.getChats();
      let chatHistory = [];

      // Define your Options for message retrieval here
      const Options = {
        limit: 10, // Number of messages to retrieve per chat (adjust as needed)
      };

      for (const chat of chats) {
        const messages = await chat.fetchMessages(Options);

        const allMessages = messages.map((message) => ({
          id: message.id.id,
          content: message.body,
          timestamp: message.timestamp,
          from: message.id.fromMe,
        }));

        chatHistory.push({
          chatId: chat.name, // Use chat.name or chat.id._serialized depending on your needs
          number: chat.id,
          isGroup: chat.isGroup,
          messages: allMessages,
        });
      }

      res.json(chatHistory);
    } else {
      res.status(400).send('WhatsApp is not yet ready.');
    }
  } catch (error) {
    console.error('Error retrieving chat history:', error);
    res.status(500).send('Error retrieving chat history.');
  }
});
  



client.on('ready', () => {
  console.log('WhatsApp Client is ready!');
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Browser Type

Google Chrome

WhatsApp Account Type

Standard

Does your WhatsApp account have multidevice enabled?

No, I am not using Multi Device

Environment

os :windows
node.js Version: v20.0.0

Additional context

No response

[ProIEZRush1]

I had today same problem, inside the onReady, try setting the client again.
client = client;

[punit-mistry]

I had today same problem, inside the onReady, try setting the client again. client = client;
client.on('ready', () => {
client=client;
console.log('WhatsApp Client is ready!');
});

still the same error

[ProIEZRush1]

Try storing the client in a new variable, newClient = client. then in the ready update it to do newClient = client

[punit-mistry]

so now whats happening is whenever i hit the /qrcode from the postman then its working fine but whenever i tried to login to through the web site that time that error is coming

[ProIEZRush1]

I'm gonna gift you a class I'm using now and the methods to adapt it to use express, works perfect.

WBClientManager.js

const path = require('path');
const os = require('os');
const qrcode = require('qrcode-terminal');

const AuthManager = require('./AuthManager');

class WBClientManager {
    constructor() {
        this.clients = new Map(); // Holds the deviceToken -> client associations
        this.qrCodes = new Map(); // Holds the deviceToken -> latest QR code associations
        this.loginTokens = new Map(); // Holds the deviceToken -> client associations
    }

    async createWBClient(deviceToken) {
        try {
            const clientOptions = {
                authStrategy: new LocalAuth({
                    clientId: deviceToken
                }),
            };

            // Set options for Linux
            if (os.platform() === 'linux') {
                clientOptions.puppeteer = {
                    args: ['--no-sandbox', '--disable-setuid-sandbox'],
                };
            }

            const client = new Client(clientOptions);
            client.on('qr', async (qr) => {
                console.log("New QR code received! for " + deviceToken);

                this.qrCodes.set(deviceToken, qr);
                this.loginTokens.set(deviceToken, "");

                // After 1 minute destroy the client
                setTimeout(async () => {
                    if (this.qrCodes.has(deviceToken)) {
                        await client.destroy();
                        this.removeClient(deviceToken);

                        console.log('Client is destroyed! for ' + deviceToken);
                    }
                }, 60000);
            });

            client.on('ready', async () => {
                this.qrCodes.delete(deviceToken);
                this.loginTokens.set(deviceToken, await AuthManager.createAnonymousUser(deviceToken));

                this.clients.set(deviceToken, client);

                console.log('Client is ready! for ' + deviceToken);
            });

            client.on('disconnected', async () => {
                this.removeClient(deviceToken);
                await AuthManager.logoutUser(deviceToken);

                console.log('Client is disconnected! for ' + deviceToken);

                await client.destroy();
            });

            this.clients.set(deviceToken, client);
            client.initialize();

            return true;
        }
        catch (error) {
            console.log(error);
            return false;
        }
    }

    getClient(session) {
        return this.clients.get(session);
    }

    getClients() {
        return this.clients.values();
    }

    getLatestQRCode(session) {
        return this.qrCodes.get(session);
    }

    getLoginToken(session) {
        return this.loginTokens.get(session);
    }

    getDeviceTokenByPhoneNumber(phoneNumber) {
        return this.phoneNumbers.get(phoneNumber);
    }

    updateDeviceTokenForPhoneNumber(phoneNumber, newSession) {
        this.phoneNumbers.set(phoneNumber, newSession);
    }

    removeClient(session) {
        this.qrCodes.delete(session);
        this.loginTokens.delete(session);
        this.clients.delete(session);
    }

    async firebaseLogout(deviceToken) {
        await AuthManager.logoutUser(deviceToken);
    }
}

// Export a singleton instance to ensure the same instance is used throughout your application
module.exports = new WBClientManager();

Example AuthHandler

const WBClientManager = require('../managers/WBClientManager');

const UploadUtils = require('../utils/UploadUtils');

class AuthHandler {

    static async handleIsLoggedIn(req, res) {
        const query = req.query;

        const deviceToken = query.deviceToken;
        if (!deviceToken) {
            const response = APIResponse.error("No device token provided", []);
            return res.send(response.toJson());
        }
        console.log("Checking if " + deviceToken + " is logged in");

        let client = WBClientManager.getClient(deviceToken);
        if (!client) {
            await WBClientManager.createWBClient(deviceToken);
            client = WBClientManager.getClient(deviceToken);
        }

        let loginToken = WBClientManager.getLoginToken(deviceToken);
        while (loginToken == undefined) {
            loginToken = WBClientManager.getLoginToken(deviceToken);
            await new Promise(resolve => setTimeout(resolve, 1000));
        }

        if (!loginToken) {
            const response = APIResponse.success("Not logged in", { loggedIn: false });
            return res.send(response.toJson());
        }

        const response = APIResponse.success("Logged in", { loggedIn: true, loginToken: loginToken });
        return res.send(response.toJson());
    }

    static async handleGenerateQRCode(req, res) {
        const query = req.query;

        const deviceToken = query.deviceToken;
        if (!deviceToken) {
            const response = APIResponse.error("No device token provided", []);
            return res.send(response.toJson());
        }
        console.log("Generating QR for " + deviceToken);

        let client = WBClientManager.getClient(deviceToken);
        if (!client) {
            await WBClientManager.createWBClient(deviceToken);
            client = WBClientManager.getClient(deviceToken);
        }

        let loginToken = WBClientManager.getLoginToken(deviceToken);
        while (loginToken == undefined) {
            loginToken = WBClientManager.getLoginToken(deviceToken);
            await new Promise(resolve => setTimeout(resolve, 1000));
        }

        if (loginToken) {
            const response = APIResponse.success("Already logged in", []);
            return res.send(response.toJson());
        }
        await WBClientManager.createWBClient(deviceToken);

        let qr = WBClientManager.getLatestQRCode(deviceToken);
        while (qr == undefined) {
            qr = WBClientManager.getLatestQRCode(deviceToken);
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
        const url = await UploadUtils.qrToUrl(deviceToken, qr);

        const response = APIResponse.success("QR generated", { qrCodeUrl: url });
        return res.send(response.toJson());
    }

}

module.exports = AuthHandler;```