Spaces:
Sleeping
Sleeping
Download src/modules/message/message.service.ts from jinksQspider/openWa: direct link, hf CLI and curl.
- Browser
- Download file 19 kB
-
https://huggingface.co/spaces/jinksQspider/openWa/resolve/main/src/modules/message/message.service.ts
- Command line
-
hf download hf://spaces/jinksQspider/openWa/src/modules/message/message.service.ts
-
curl -L -o message.service.ts https://huggingface.co/spaces/jinksQspider/openWa/resolve/main/src/modules/message/message.service.ts
19 kB
| import { Injectable, BadRequestException } from '@nestjs/common'; | |
| import { InjectRepository } from '@nestjs/typeorm'; | |
| import { Repository } from 'typeorm'; | |
| import { SessionService } from '../session/session.service'; | |
| import { SendTextMessageDto, SendMediaMessageDto, MessageResponseDto } from './dto'; | |
| import { SendTemplateMessageDto } from './dto/send-template.dto'; | |
| import { MediaInput } from '../../engine/interfaces/whatsapp-engine.interface'; | |
| import { Message, MessageDirection, MessageStatus } from './entities/message.entity'; | |
| import { HookManager } from '../../core/hooks'; | |
| import { TemplateService } from '../template/template.service'; | |
| import { renderTemplate } from '../../common/utils/template-render'; | |
| import { createLogger } from '../../common/services/logger.service'; | |
| export interface GetMessagesOptions { | |
| chatId?: string; | |
| limit?: number; | |
| offset?: number; | |
| } | |
| () | |
| export class MessageService { | |
| private readonly logger = createLogger('MessageService'); | |
| constructor( | |
| (Message, 'data') | |
| private readonly messageRepository: Repository<Message>, | |
| private readonly sessionService: SessionService, | |
| private readonly hookManager: HookManager, | |
| private readonly templateService: TemplateService, | |
| ) {} | |
| async sendText(sessionId: string, dto: SendTextMessageDto): Promise<MessageResponseDto> { | |
| // Execute hook before sending - plugins can modify or block | |
| const { continue: shouldContinue, data: hookData } = await this.hookManager.execute( | |
| 'message:sending', | |
| { sessionId, input: dto, type: 'text' }, | |
| { sessionId, source: 'MessageService' }, | |
| ); | |
| if (!shouldContinue) { | |
| throw new BadRequestException('Message sending blocked by plugin'); | |
| } | |
| // Use potentially modified input | |
| const finalDto = (hookData as { input: SendTextMessageDto }).input; | |
| const engine = this.getEngine(sessionId); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: finalDto.chatId, | |
| body: finalDto.text, | |
| type: 'text', | |
| }); | |
| try { | |
| const result = await engine.sendTextMessage(finalDto.chatId, finalDto.text); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| // Note: the `message:sent` hook is emitted solely by SessionService.onMessageCreate (engine | |
| // `message_create`) with a consistent IncomingMessage payload for ALL sends (text, media, | |
| // and phone-composed), so it is intentionally not fired here to avoid a double dispatch. | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| // Mark as failed | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| // Execute hook on failure | |
| await this.hookManager.execute( | |
| 'message:failed', | |
| { sessionId, error: error instanceof Error ? error.message : String(error), input: finalDto }, | |
| { sessionId, source: 'MessageService' }, | |
| ); | |
| throw error; | |
| } | |
| } | |
| /** | |
| * Resolve a stored template, render its body (with optional header/footer | |
| * flattened using newlines) using the supplied variables, and delegate to the | |
| * existing {@link sendText} path so plugin hooks, persistence, and status | |
| * tracking are reused. Throws NotFoundException when the template cannot be | |
| * resolved by id or name. | |
| */ | |
| async sendTemplate(sessionId: string, dto: SendTemplateMessageDto): Promise<MessageResponseDto> { | |
| const template = await this.templateService.resolve(sessionId, { | |
| templateId: dto.templateId, | |
| templateName: dto.templateName, | |
| }); | |
| const vars = dto.vars ?? {}; | |
| const segments = [template.header, template.body, template.footer] | |
| .filter((segment): segment is string => segment != null && segment.length > 0) | |
| .map(segment => renderTemplate(segment, vars)); | |
| const text = segments.join('\n\n'); | |
| return this.sendText(sessionId, { chatId: dto.chatId, text }); | |
| } | |
| async sendImage(sessionId: string, dto: SendMediaMessageDto): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| const media = this.buildMediaInput(dto); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: dto.caption || '', | |
| type: 'image', | |
| metadata: { | |
| media: { mimetype: dto.mimetype, filename: dto.filename, data: dto.base64 || dto.url }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.sendImageMessage(dto.chatId, media); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async sendVideo(sessionId: string, dto: SendMediaMessageDto): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| const media = this.buildMediaInput(dto); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: dto.caption || '', | |
| type: 'video', | |
| metadata: { | |
| media: { mimetype: dto.mimetype, filename: dto.filename, data: dto.base64 || dto.url }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.sendVideoMessage(dto.chatId, media); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async sendAudio(sessionId: string, dto: SendMediaMessageDto): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| const media = this.buildMediaInput(dto); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| type: 'audio', | |
| metadata: { | |
| media: { mimetype: dto.mimetype, filename: dto.filename, data: dto.base64 || dto.url }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.sendAudioMessage(dto.chatId, media); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async sendDocument(sessionId: string, dto: SendMediaMessageDto): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| const media = this.buildMediaInput(dto); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: dto.filename || '', | |
| type: 'document', | |
| metadata: { | |
| media: { mimetype: dto.mimetype, filename: dto.filename, data: dto.base64 || dto.url }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.sendDocumentMessage(dto.chatId, media); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| /** | |
| * Get message history for a session | |
| */ | |
| async getMessages( | |
| sessionId: string, | |
| options: GetMessagesOptions = {}, | |
| ): Promise<{ messages: Message[]; total: number }> { | |
| const { chatId, limit = 50, offset = 0 } = options; | |
| const query = this.messageRepository | |
| .createQueryBuilder('message') | |
| .where('message.sessionId = :sessionId', { sessionId }) | |
| .orderBy('message.createdAt', 'DESC') | |
| .skip(offset) | |
| .take(limit); | |
| if (chatId) { | |
| query.andWhere('message.chatId = :chatId', { chatId }); | |
| } | |
| const [messages, total] = await query.getManyAndCount(); | |
| return { messages, total }; | |
| } | |
| // ========== Phase 3: Extended Messaging ========== | |
| async sendLocation( | |
| sessionId: string, | |
| dto: { chatId: string; latitude: number; longitude: number; description?: string; address?: string }, | |
| ): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: `📍 ${dto.description || 'Location'}`, | |
| type: 'location', | |
| }); | |
| try { | |
| const result = await engine.sendLocationMessage(dto.chatId, { | |
| latitude: dto.latitude, | |
| longitude: dto.longitude, | |
| description: dto.description, | |
| address: dto.address, | |
| }); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async sendContact( | |
| sessionId: string, | |
| dto: { chatId: string; contactName: string; contactNumber: string }, | |
| ): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: `📇 ${dto.contactName}`, | |
| type: 'contact', | |
| }); | |
| try { | |
| const result = await engine.sendContactMessage(dto.chatId, { | |
| name: dto.contactName, | |
| number: dto.contactNumber, | |
| }); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async sendSticker(sessionId: string, dto: SendMediaMessageDto): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| const media = this.buildMediaInput(dto); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| type: 'sticker', | |
| metadata: { | |
| media: { mimetype: dto.mimetype, filename: dto.filename, data: dto.base64 || dto.url }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.sendStickerMessage(dto.chatId, media); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async reply( | |
| sessionId: string, | |
| dto: { chatId: string; quotedMessageId: string; text: string }, | |
| ): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| // Resolve the quoted message body (best-effort) so the dashboard can render the reply preview. | |
| let quotedBody = ''; | |
| try { | |
| const quoted = await this.messageRepository.findOne({ | |
| where: { sessionId, waMessageId: dto.quotedMessageId }, | |
| }); | |
| quotedBody = quoted?.body || ''; | |
| } catch (err) { | |
| this.logger.warn(`Failed to resolve quoted message ${dto.quotedMessageId}`, { error: String(err) }); | |
| } | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.chatId, | |
| body: dto.text, | |
| type: 'text', | |
| metadata: { | |
| quotedMessage: { id: dto.quotedMessageId, body: quotedBody }, | |
| }, | |
| }); | |
| try { | |
| const result = await engine.replyToMessage(dto.chatId, dto.quotedMessageId, dto.text); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| async forward( | |
| sessionId: string, | |
| dto: { fromChatId: string; toChatId: string; messageId: string }, | |
| ): Promise<MessageResponseDto> { | |
| const engine = this.getEngine(sessionId); | |
| // Save message as pending BEFORE sending | |
| const message = await this.saveOutgoingMessage(sessionId, { | |
| chatId: dto.toChatId, | |
| body: '[Forwarded]', | |
| type: 'forward', | |
| }); | |
| try { | |
| const result = await engine.forwardMessage(dto.fromChatId, dto.toChatId, dto.messageId); | |
| // Update with actual WhatsApp message ID and status | |
| message.waMessageId = result.id; | |
| message.status = MessageStatus.SENT; | |
| message.timestamp = result.timestamp; | |
| await this.messageRepository.save(message); | |
| return { | |
| messageId: result.id, | |
| timestamp: result.timestamp, | |
| }; | |
| } catch (error) { | |
| message.status = MessageStatus.FAILED; | |
| await this.messageRepository.save(message); | |
| throw error; | |
| } | |
| } | |
| /** | |
| * Save incoming message (called from session webhook dispatch) | |
| */ | |
| async saveIncomingMessage(sessionId: string, data: Partial<Message>): Promise<Message> { | |
| const message = this.messageRepository.create({ | |
| ...data, | |
| sessionId, | |
| direction: MessageDirection.INCOMING, | |
| }); | |
| return this.messageRepository.save(message); | |
| } | |
| /** | |
| * Save outgoing message to database. | |
| * When called before sending, creates a record with PENDING status. | |
| */ | |
| private async saveOutgoingMessage( | |
| sessionId: string, | |
| data: { | |
| waMessageId?: string; | |
| chatId: string; | |
| body?: string; | |
| type: string; | |
| timestamp?: number; | |
| status?: MessageStatus; | |
| metadata?: Record<string, unknown>; | |
| }, | |
| ): Promise<Message> { | |
| const session = await this.sessionService.findOne(sessionId); | |
| const message = this.messageRepository.create({ | |
| sessionId, | |
| waMessageId: data.waMessageId, | |
| chatId: data.chatId, | |
| from: session?.phone || 'me', | |
| to: data.chatId, | |
| body: data.body, | |
| type: data.type, | |
| direction: MessageDirection.OUTGOING, | |
| timestamp: data.timestamp, | |
| status: data.status ?? MessageStatus.PENDING, | |
| metadata: data.metadata, | |
| }); | |
| return this.messageRepository.save(message); | |
| } | |
| // ========== Phase 3: Reactions ========== | |
| async reactToMessage(sessionId: string, dto: { chatId: string; messageId: string; emoji: string }): Promise<void> { | |
| const engine = this.getEngine(sessionId); | |
| await engine.reactToMessage(dto.chatId, dto.messageId, dto.emoji); | |
| } | |
| async getMessageReactions(sessionId: string, chatId: string, messageId: string) { | |
| const engine = this.getEngine(sessionId); | |
| return engine.getMessageReactions(chatId, messageId); | |
| } | |
| /** Maximum messages a single getChatHistory call may request from the engine. */ | |
| private static readonly MAX_CHAT_HISTORY_LIMIT = 100; | |
| /** | |
| * Fetch chat history live from WhatsApp (bypasses local DB). | |
| * Returns the most recent `limit` messages for the given chat. | |
| * When `includeMedia` is true, downloads media (base64) for messages that have it. | |
| * | |
| * `limit` is clamped to [1, 100] (and falls back to 50 for non-finite input) so a | |
| * caller cannot ask the engine to fetch an unbounded number of messages. | |
| */ | |
| async getChatHistory(sessionId: string, chatId: string, limit = 50, includeMedia = false) { | |
| const engine = this.getEngine(sessionId); | |
| const safeLimit = Number.isFinite(limit) | |
| ? Math.min(Math.max(Math.trunc(limit), 1), MessageService.MAX_CHAT_HISTORY_LIMIT) | |
| : 50; | |
| return engine.getChatHistory(chatId, safeLimit, includeMedia); | |
| } | |
| // ========== Delete Message ========== | |
| async deleteMessage( | |
| sessionId: string, | |
| dto: { chatId: string; messageId: string; forEveryone?: boolean }, | |
| ): Promise<void> { | |
| const engine = this.getEngine(sessionId); | |
| await engine.deleteMessage(dto.chatId, dto.messageId, dto.forEveryone ?? true); | |
| // Flag the stored message as revoked. No localized display string is persisted here; | |
| // the dashboard renders the localized "message deleted" text. | |
| try { | |
| await this.messageRepository.update({ sessionId, waMessageId: dto.messageId }, { body: '', type: 'revoked' }); | |
| } catch (err) { | |
| this.logger.warn(`Failed to flag deleted message ${dto.messageId} as revoked`, { error: String(err) }); | |
| } | |
| } | |
| private getEngine(sessionId: string) { | |
| const engine = this.sessionService.getEngine(sessionId); | |
| if (!engine) { | |
| throw new BadRequestException(`Session '${sessionId}' is not active. Start the session first.`); | |
| } | |
| return engine; | |
| } | |
| private buildMediaInput(dto: SendMediaMessageDto): MediaInput { | |
| if (!dto.url && !dto.base64) { | |
| throw new BadRequestException('Either url or base64 must be provided'); | |
| } | |
| if (dto.base64 && !dto.mimetype) { | |
| throw new BadRequestException('mimetype is required when using base64 data'); | |
| } | |
| return { | |
| mimetype: dto.mimetype || 'application/octet-stream', | |
| data: dto.url || dto.base64!, | |
| filename: dto.filename, | |
| caption: dto.caption, | |
| }; | |
| } | |
| } | |