fix: auto-load instances from database when not in memory

Author: Hamza Shahid

src/api/controllers/instance.controller.ts

@@ -34,6 +34,62 @@ export class InstanceController {
 
   private readonly logger = new Logger('InstanceController');
 
+  // Helper to get or load instance from database
+  private async getOrLoadInstance(instanceName: string) {
+    // Check if already in memory
+    if (this.waMonitor.waInstances[instanceName]) {
+      return this.waMonitor.waInstances[instanceName];
+    }
+
+    // Try to load from database
+    const dbInstance = await this.prismaRepository.instance.findFirst({
+      where: { name: instanceName },
+    });
+
+    if (!dbInstance) {
+      return null;
+    }
+
+    // Initialize the instance
+    const instanceData: InstanceDto = {
+      instanceName: dbInstance.name,
+      instanceId: dbInstance.id,
+      integration: dbInstance.integration as any,
+      token: dbInstance.token,
+      number: dbInstance.number,
+      businessId: dbInstance.businessId,
+    };
+
+    const instance = channelController.init(instanceData, {
+      configService: this.configService,
+      eventEmitter: this.eventEmitter,
+      prismaRepository: this.prismaRepository,
+      cache: this.cache,
+      chatwootCache: this.chatwootCache,
+      baileysCache: this.baileysCache,
+      providerFiles: this.providerFiles,
+    });
+
+    if (!instance) {
+      return null;
+    }
+
+    instance.setInstance({
+      instanceId: dbInstance.id,
+      instanceName: dbInstance.name,
+      integration: dbInstance.integration as any,
+      token: dbInstance.token,
+      number: dbInstance.number,
+      businessId: dbInstance.businessId,
+      ownerJid: dbInstance.ownerJid,
+    });
+
+    this.waMonitor.waInstances[instanceName] = instance;
+    this.logger.info(`Instance "${instanceName}" loaded from database`);
+
+    return instance;
+  }
+
   public async createInstance(instanceData: InstanceDto) {
     try {
       const instance = channelController.init(instanceData, {
@@ -308,13 +364,15 @@ export class InstanceController {
 
   public async connectToWhatsapp({ instanceName, number = null }: InstanceDto) {
     try {
-      const instance = this.waMonitor.waInstances[instanceName];
-      const state = instance?.connectionStatus?.state;
+      // Get instance from memory or load from database
+      const instance = await this.getOrLoadInstance(instanceName);
 
-      if (!state) {
+      if (!instance) {
         throw new BadRequestException('The "' + instanceName + '" instance does not exist');
       }
 
+      const state = instance?.connectionStatus?.state;
+
       if (state == 'open') {
         return await this.connectionState({ instanceName });
       }
@@ -323,20 +381,10 @@ export class InstanceController {
         return instance.qrCode;
       }
 
-      if (state == 'close') {
-        await instance.connectToWhatsapp(number);
-
-        await delay(2000);
-        return instance.qrCode;
-      }
-
-      return {
-        instance: {
-          instanceName: instanceName,
-          status: state,
-        },
-        qrcode: instance?.qrCode,
-      };
+      // Connect if closed or no state
+      await instance.connectToWhatsapp(number);
+      await delay(2000);
+      return instance.qrCode;
     } catch (error) {
       this.logger.error(error);
       return { error: true, message: error.toString() };
@@ -345,13 +393,14 @@ export class InstanceController {
 
   public async restartInstance({ instanceName }: InstanceDto) {
     try {
-      const instance = this.waMonitor.waInstances[instanceName];
-      const state = instance?.connectionStatus?.state;
+      const instance = await this.getOrLoadInstance(instanceName);
 
-      if (!state) {
+      if (!instance) {
         throw new BadRequestException('The "' + instanceName + '" instance does not exist');
       }
 
+      const state = instance?.connectionStatus?.state;
+
       if (state === 'close') {
         throw new BadRequestException('The "' + instanceName + '" instance is not connected');
       }

src/api/controllers/sendMessage.controller.ts

@@ -31,22 +31,23 @@ function isEmoji(str: string) {
 export class SendMessageController {
   constructor(private readonly waMonitor: WAMonitoringService) {}
 
-  private getInstance(instanceName: string) {
-    const instance = this.waMonitor.waInstances[instanceName];
+  private async getInstance(instanceName: string) {
+    // Try to get from memory or load from database
+    const instance = await this.waMonitor.getOrLoadInstance(instanceName);
     if (!instance) {
-      throw new NotFoundException(
-        `Instance "${instanceName}" not found or not connected. Please connect the instance first.`,
-      );
+      throw new NotFoundException(`Instance "${instanceName}" not found. Please create the instance first.`);
     }
     return instance;
   }
 
   public async sendTemplate({ instanceName }: InstanceDto, data: SendTemplateDto) {
-    return await this.getInstance(instanceName).templateMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.templateMessage(data);
   }
 
   public async sendText({ instanceName }: InstanceDto, data: SendTextDto) {
-    return await this.getInstance(instanceName).textMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.textMessage(data);
   }
 
   public async sendMedia({ instanceName }: InstanceDto, data: SendMediaDto, file?: any) {
@@ -55,62 +56,73 @@ export class SendMessageController {
     }
 
     if (file || isURL(data?.media) || isBase64(data?.media)) {
-      return await this.getInstance(instanceName).mediaMessage(data, file);
+      const instance = await this.getInstance(instanceName);
+      return await instance.mediaMessage(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
 
   public async sendPtv({ instanceName }: InstanceDto, data: SendPtvDto, file?: any) {
     if (file || isURL(data?.video) || isBase64(data?.video)) {
-      return await this.getInstance(instanceName).ptvMessage(data, file);
+      const instance = await this.getInstance(instanceName);
+      return await instance.ptvMessage(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
 
   public async sendSticker({ instanceName }: InstanceDto, data: SendStickerDto, file?: any) {
     if (file || isURL(data.sticker) || isBase64(data.sticker)) {
-      return await this.getInstance(instanceName).mediaSticker(data, file);
+      const instance = await this.getInstance(instanceName);
+      return await instance.mediaSticker(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
 
   public async sendWhatsAppAudio({ instanceName }: InstanceDto, data: SendAudioDto, file?: any) {
     if (file?.buffer || isURL(data.audio) || isBase64(data.audio)) {
-      return await this.getInstance(instanceName).audioWhatsapp(data, file);
+      const instance = await this.getInstance(instanceName);
+      return await instance.audioWhatsapp(data, file);
     } else {
       console.error('El archivo no tiene buffer o el audio no es una URL o Base64 válida');
       throw new BadRequestException('Owned media must be a url, base64, or valid file with buffer');
     }
   }
 
   public async sendButtons({ instanceName }: InstanceDto, data: SendButtonsDto) {
-    return await this.getInstance(instanceName).buttonMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.buttonMessage(data);
   }
 
   public async sendLocation({ instanceName }: InstanceDto, data: SendLocationDto) {
-    return await this.getInstance(instanceName).locationMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.locationMessage(data);
   }
 
   public async sendList({ instanceName }: InstanceDto, data: SendListDto) {
-    return await this.getInstance(instanceName).listMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.listMessage(data);
   }
 
   public async sendContact({ instanceName }: InstanceDto, data: SendContactDto) {
-    return await this.getInstance(instanceName).contactMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.contactMessage(data);
   }
 
   public async sendReaction({ instanceName }: InstanceDto, data: SendReactionDto) {
     if (!isEmoji(data.reaction)) {
       throw new BadRequestException('Reaction must be a single emoji or empty string');
     }
-    return await this.getInstance(instanceName).reactionMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.reactionMessage(data);
   }
 
   public async sendPoll({ instanceName }: InstanceDto, data: SendPollDto) {
-    return await this.getInstance(instanceName).pollMessage(data);
+    const instance = await this.getInstance(instanceName);
+    return await instance.pollMessage(data);
   }
 
   public async sendStatus({ instanceName }: InstanceDto, data: SendStatusDto, file?: any) {
-    return await this.getInstance(instanceName).statusMessage(data, file);
+    const instance = await this.getInstance(instanceName);
+    return await instance.statusMessage(data, file);
   }
 }

src/api/services/monitor.service.ts

@@ -42,6 +42,62 @@ export class WAMonitoringService {
 
   private readonly providerSession: ProviderSession;
 
+  // Public helper to get instance from memory or load from database
+  public async getOrLoadInstance(instanceName: string) {
+    // Check if already in memory
+    if (this.waInstances[instanceName]) {
+      return this.waInstances[instanceName];
+    }
+
+    // Try to load from database
+    const dbInstance = await this.prismaRepository.instance.findFirst({
+      where: { name: instanceName },
+    });
+
+    if (!dbInstance) {
+      return null;
+    }
+
+    // Initialize the instance
+    const instanceData: InstanceDto = {
+      instanceName: dbInstance.name,
+      instanceId: dbInstance.id,
+      integration: dbInstance.integration as any,
+      token: dbInstance.token,
+      number: dbInstance.number,
+      businessId: dbInstance.businessId,
+    };
+
+    const instance = channelController.init(instanceData, {
+      configService: this.configService,
+      eventEmitter: this.eventEmitter,
+      prismaRepository: this.prismaRepository,
+      cache: this.cache,
+      chatwootCache: this.chatwootCache,
+      baileysCache: this.baileysCache,
+      providerFiles: this.providerFiles,
+    });
+
+    if (!instance) {
+      return null;
+    }
+
+    instance.setInstance({
+      instanceId: dbInstance.id,
+      instanceName: dbInstance.name,
+      integration: dbInstance.integration as any,
+      token: dbInstance.token,
+      number: dbInstance.number,
+      businessId: dbInstance.businessId,
+      ownerJid: dbInstance.ownerJid,
+    });
+
+    this.waInstances[instanceName] = instance;
+    this.logger.info(`Instance "${instanceName}" loaded from database on-demand`);
+
+    return instance;
+  }
+
   public delInstanceTime(instance: string) {
     const time = this.configService.get<DelInstance>('DEL_INSTANCE');
     if (typeof time === 'number' && time > 0) {