openWa / src /modules /message /message.service.ts
harsh
Deploy: Initial commit without binaries
525d39f
Raw History Blame Contribute Delete
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;
}
@Injectable()
export class MessageService {
private readonly logger = createLogger('MessageService');
constructor(
@InjectRepository(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,
};
}
}