aiolabs/webapp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace complex UnreadMessageData system with elegant path-based wildcard notification tracking inspired by Coracle's pattern. This simplifies the codebase while adding powerful batch "mark as read" capabilities.

Browse source 
Key changes:
  - Add notification store with path-based wildcard support (chat/*, chat/{pubkey}, *)
  - Remove UnreadMessageData interface and processedMessageIds Set tracking
  - Implement timestamp-based "seen at" logic with wildcard matching
  - Add markAllChatsAsRead() for batch operations
  - Integrate ChatNotificationConfig for module configuration
  - Create useNotifications composable for easy notification access

  Benefits:
  - Simpler architecture (removed processedMessageIds complexity)
  - Flexible wildcard-based "mark as read" operations
  - Future-proof for Primal-style backend sync
  - User-scoped storage via StorageService
  - Clean separation of concerns

refactor: enhance chat service with activity tracking and sorting

- Updated the ChatService to track lastSent, lastReceived, and lastChecked timestamps for peers, improving message handling and user experience.
- Implemented sorting of peers by last activity to prioritize recent conversations.
- Adjusted message handling to update peer activity based on message direction.
- Ensured updated peer data is saved to storage after modifications.

These changes streamline chat interactions and enhance the overall functionality of the chat service.

refactor: improve ChatService and notification store initialization

- Updated ChatService to ensure the notification store is initialized only after user authentication, preventing potential errors.
- Introduced a new method to safely access the notification store, enhancing error handling.
- Enhanced peer activity tracking by calculating last activity based on actual message timestamps, improving sorting and user experience.
- Added debounced saving of notification state to storage, optimizing performance and reducing unnecessary writes.
- Improved logging for better debugging and visibility into notification handling processes.

These changes enhance the reliability and efficiency of the chat service and notification management.

refactor: clean up logging in ChatService and notification store

- Removed unnecessary console logs from ChatService to streamline the code and improve performance.
- Simplified the initialization process of the notification store by eliminating redundant logging statements.
- Enhanced readability and maintainability of the code by focusing on essential operations without excessive debug output.

These changes contribute to a cleaner codebase and improved performance in chat service operations.

FIX BUILD ERRORS

refactor: update chat module notification configuration

- Refactored the notification settings in the chat module to use a nested structure, enhancing clarity and organization.
- Introduced `wildcardSupport` to the notification configuration, allowing for more flexible notification handling.
- Maintained existing functionality while improving the overall configuration structure.

These changes contribute to a more maintainable and extensible chat module configuration.

refactor: optimize ChatComponent and ChatService for improved performance

- Removed unnecessary sorting of peers in ChatComponent, leveraging the existing order provided by the chat service.
- Updated the useFuzzySearch composable to directly utilize the sorted peers, enhancing search efficiency.
- Cleaned up logging in ChatService by removing redundant console statements, streamlining the codebase.
- Added critical checks to prevent the current user from being included in peer interactions, improving user experience and functionality.

These changes contribute to a more efficient and maintainable chat module.

refactor: simplify message publishing in ChatService

- Removed unnecessary variable assignment in the message publishing process, directly awaiting the relayHub.publishEvent call.
- This change streamlines the code and enhances readability without altering functionality.

These modifications contribute to a cleaner and more efficient chat service implementation.
This commit is contained in:
padreug 2025-10-02 10:01:26 +02:00
parent 0447549fa5
commit 0da23e9332
8 changed files with 535 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

313
src/modules/chat/services/chat-service.ts
View file

@ -2,9 +2,10 @@ import { ref, computed } from 'vue'
import { eventBus } from '@/core/event-bus'
import { BaseService } from '@/core/base/BaseService'
import { nip04, finalizeEvent, type Event, type EventTemplate } from 'nostr-tools'
import type { ChatMessage, ChatPeer, UnreadMessageData, ChatConfig } from '../types'
import type { ChatMessage, ChatPeer, ChatConfig } from '../types'
import { getAuthToken } from '@/lib/config/lnbits'
import { config } from '@/lib/config'
import { useChatNotificationStore } from '../stores/notification'
export class ChatService extends BaseService {
// Service metadata
protected readonly metadata = {
@ -21,20 +22,35 @@ export class ChatService extends BaseService {
private visibilityUnsubscribe?: () => void
private isFullyInitialized = false
private authCheckInterval?: ReturnType<typeof setInterval>
private notificationStore?: ReturnType<typeof useChatNotificationStore>
constructor(config: ChatConfig) {
super()
this.config = config
this.loadPeersFromStorage()
// NOTE: DO NOT call loadPeersFromStorage() here - it depends on StorageService
// which may not be available yet. Moved to onInitialize().
}
// Register market message handler for forwarding market-related DMs
setMarketMessageHandler(handler: (event: any) => Promise<void>) {
this.marketMessageHandler = handler
}
/**
* Get the notification store, ensuring it's initialized
* CRITICAL: This must only be called after onInitialize() has run
*/
private getNotificationStore(): ReturnType<typeof useChatNotificationStore> {
if (!this.notificationStore) {
throw new Error('ChatService: Notification store not initialized yet. This should not happen after onInitialize().')
}
return this.notificationStore
}
/**
* Service-specific initialization (called by BaseService)
*/
protected async onInitialize(): Promise<void> {
this.debug('Chat service onInitialize called')
// Check both injected auth service AND global auth composable
// Removed dual auth import
const hasAuthService = this.authService?.user?.value?.pubkey
@ -83,6 +99,13 @@ export class ChatService extends BaseService {
return
}
this.debug('Completing chat service initialization...')
// CRITICAL: Initialize notification store AFTER user is authenticated
// StorageService needs user pubkey to scope the storage keys correctly
if (!this.notificationStore) {
this.notificationStore = useChatNotificationStore()
}
// Load peers from storage first
this.loadPeersFromStorage()
// Load peers from API
@ -106,12 +129,59 @@ export class ChatService extends BaseService {
}
// Computed properties
get allPeers() {
return computed(() => Array.from(this.peers.value.values()))
return computed(() => {
const peers = Array.from(this.peers.value.values())
// Sort by last activity (Coracle pattern)
// Most recent conversation first
return peers.sort((a, b) => {
// Calculate activity from actual messages (source of truth)
const aMessages = this.getMessages(a.pubkey)
const bMessages = this.getMessages(b.pubkey)
let aActivity = 0
let bActivity = 0
// Get last message timestamp from actual messages
if (aMessages.length > 0) {
const lastMsg = aMessages[aMessages.length - 1]
aActivity = lastMsg.created_at
} else {
// Fallback to stored timestamps only if no messages
aActivity = Math.max(a.lastSent || 0, a.lastReceived || 0)
}
if (bMessages.length > 0) {
const lastMsg = bMessages[bMessages.length - 1]
bActivity = lastMsg.created_at
} else {
// Fallback to stored timestamps only if no messages
bActivity = Math.max(b.lastSent || 0, b.lastReceived || 0)
}
// Peers with activity always come before peers without activity
if (aActivity > 0 && bActivity === 0) return -1
if (aActivity === 0 && bActivity > 0) return 1
// Primary sort: by activity timestamp (descending - most recent first)
if (bActivity !== aActivity) {
return bActivity - aActivity
}
// Stable tiebreaker: sort by pubkey (prevents random reordering)
return a.pubkey.localeCompare(b.pubkey)
})
})
}
get totalUnreadCount() {
return computed(() => {
if (!this.notificationStore) return 0 // Not initialized yet
return Array.from(this.peers.value.values())
.reduce((total, peer) => total + peer.unreadCount, 0)
.reduce((total, peer) => {
const messages = this.getMessages(peer.pubkey)
const unreadCount = this.getNotificationStore().getUnreadCount(peer.pubkey, messages)
return total + unreadCount
}, 0)
})
}
get isReady() {
@ -123,7 +193,13 @@ export class ChatService extends BaseService {
}
// Get peer by pubkey
getPeer(pubkey: string): ChatPeer | undefined {
return this.peers.value.get(pubkey)
const peer = this.peers.value.get(pubkey)
if (peer && this.notificationStore) {
// Update unread count from notification store (only if store is initialized)
const messages = this.getMessages(pubkey)
peer.unreadCount = this.getNotificationStore().getUnreadCount(pubkey, messages)
}
return peer
}
// Add or update a peer
addPeer(pubkey: string, name?: string): ChatPeer {
@ -133,7 +209,9 @@ export class ChatService extends BaseService {
pubkey,
name: name || `User ${pubkey.slice(0, 8)}`,
unreadCount: 0,
lastSeen: Date.now()
lastSent: 0,
lastReceived: 0,
lastChecked: 0
}
this.peers.value.set(pubkey, peer)
this.savePeersToStorage()
@ -153,7 +231,7 @@ export class ChatService extends BaseService {
// Avoid duplicates
if (!peerMessages.some(m => m.id === message.id)) {
peerMessages.push(message)
// Sort by timestamp
// Sort by timestamp (ascending - chronological order within conversation)
peerMessages.sort((a, b) => a.created_at - b.created_at)
// Limit message count
if (peerMessages.length > this.config.maxMessages) {
@ -162,42 +240,95 @@ export class ChatService extends BaseService {
// Update peer info
const peer = this.addPeer(peerPubkey)
peer.lastMessage = message
peer.lastSeen = Date.now()
// Update unread count if message is not sent by us
if (!message.sent) {
this.updateUnreadCount(peerPubkey, message)
// Update lastSent or lastReceived based on message direction (Coracle pattern)
if (message.sent) {
peer.lastSent = Math.max(peer.lastSent, message.created_at)
} else {
peer.lastReceived = Math.max(peer.lastReceived, message.created_at)
}
// Update unread count from notification store (only if store is initialized)
const messages = this.getMessages(peerPubkey)
const unreadCount = this.notificationStore
? this.getNotificationStore().getUnreadCount(peerPubkey, messages)
: 0
peer.unreadCount = unreadCount
// Save updated peer data
this.savePeersToStorage()
// Emit events
const eventType = message.sent ? 'chat:message-sent' : 'chat:message-received'
eventBus.emit(eventType, { message, peerPubkey }, 'chat-service')
// Emit unread count change if message is not sent by us
if (!message.sent) {
eventBus.emit('chat:unread-count-changed', {
peerPubkey,
count: unreadCount,
totalUnread: this.totalUnreadCount.value
}, 'chat-service')
}
}
}
// Mark messages as read for a peer
markAsRead(peerPubkey: string): void {
markAsRead(peerPubkey: string, timestamp?: number): void {
const peer = this.peers.value.get(peerPubkey)
if (peer && peer.unreadCount > 0) {
peer.unreadCount = 0
// Save unread state
const unreadData: UnreadMessageData = {
lastReadTimestamp: Date.now(),
unreadCount: 0,
processedMessageIds: new Set()
if (peer) {
const ts = timestamp || Math.floor(Date.now() / 1000)
// Update lastChecked timestamp (Coracle pattern)
const oldChecked = peer.lastChecked
peer.lastChecked = Math.max(peer.lastChecked, ts)
// Use notification store to mark as read
this.getNotificationStore().markChatAsRead(peerPubkey, timestamp)
// Update peer unread count
const messages = this.getMessages(peerPubkey)
const oldUnreadCount = peer.unreadCount
peer.unreadCount = this.getNotificationStore().getUnreadCount(peerPubkey, messages)
// Only save if something actually changed (prevent unnecessary reactivity)
if (oldChecked !== peer.lastChecked || oldUnreadCount !== peer.unreadCount) {
this.savePeersToStorage()
}
// Emit event only if unread count changed
if (oldUnreadCount !== peer.unreadCount) {
eventBus.emit('chat:unread-count-changed', {
peerPubkey,
count: peer.unreadCount,
totalUnread: this.totalUnreadCount.value
}, 'chat-service')
}
this.saveUnreadData(peerPubkey, unreadData)
eventBus.emit('chat:unread-count-changed', {
peerPubkey,
count: 0,
totalUnread: this.totalUnreadCount.value
}, 'chat-service')
}
}
// Mark all chats as read
markAllChatsAsRead(): void {
this.getNotificationStore().markAllChatsAsRead()
// Update all peers' unread counts
Array.from(this.peers.value.values()).forEach(peer => {
const messages = this.getMessages(peer.pubkey)
peer.unreadCount = this.getNotificationStore().getUnreadCount(peer.pubkey, messages)
})
// Emit event
eventBus.emit('chat:unread-count-changed', {
peerPubkey: '*',
count: 0,
totalUnread: 0
}, 'chat-service')
}
// Refresh peers from API
async refreshPeers(): Promise<void> {
// Check if we should trigger full initialization
// Removed dual auth import
const hasAuth = this.authService?.user?.value?.pubkey
if (!this.isFullyInitialized && hasAuth) {
console.log('💬 Refresh peers triggered full initialization')
await this.completeInitialization()
}
return this.loadPeersFromAPI()
@ -252,8 +383,7 @@ export class ChatService extends BaseService {
// Add to local messages immediately
this.addMessage(peerPubkey, message)
// Publish to Nostr relays
const result = await relayHub.publishEvent(signedEvent)
console.log('Message published to relays:', { success: result.success, total: result.total })
await relayHub.publishEvent(signedEvent)
} catch (error) {
console.error('Failed to send message:', error)
throw error
@ -272,42 +402,6 @@ export class ChatService extends BaseService {
return bytes
}
private updateUnreadCount(peerPubkey: string, message: ChatMessage): void {
const unreadData = this.getUnreadData(peerPubkey)
if (!unreadData.processedMessageIds.has(message.id)) {
unreadData.processedMessageIds.add(message.id)
unreadData.unreadCount++
const peer = this.peers.value.get(peerPubkey)
if (peer) {
peer.unreadCount = unreadData.unreadCount
this.savePeersToStorage()
}
this.saveUnreadData(peerPubkey, unreadData)
eventBus.emit('chat:unread-count-changed', {
peerPubkey,
count: unreadData.unreadCount,
totalUnread: this.totalUnreadCount.value
}, 'chat-service')
}
}
private getUnreadData(peerPubkey: string): UnreadMessageData {
const data = this.storageService.getUserData(`chat-unread-messages-${peerPubkey}`, {
lastReadTimestamp: 0,
unreadCount: 0,
processedMessageIds: []
})
return {
...data,
processedMessageIds: new Set(data.processedMessageIds || [])
}
}
private saveUnreadData(peerPubkey: string, data: UnreadMessageData): void {
const serializable = {
...data,
processedMessageIds: Array.from(data.processedMessageIds)
}
this.storageService.setUserData(`chat-unread-messages-${peerPubkey}`, serializable)
}
// Load peers from API
async loadPeersFromAPI(): Promise<void> {
try {
@ -316,9 +410,15 @@ export class ChatService extends BaseService {
console.warn('💬 No authentication token found for loading peers from API')
throw new Error('No authentication token found')
}
// Get current user pubkey to exclude from peers
const currentUserPubkey = this.authService?.user?.value?.pubkey
if (!currentUserPubkey) {
console.warn('💬 No current user pubkey available')
}
const API_BASE_URL = config.api.baseUrl || 'http://localhost:5006'
console.log('💬 Loading peers from API:', `${API_BASE_URL}/api/v1/auth/nostr/pubkeys`)
const response = await fetch(`${API_BASE_URL}/api/v1/auth/nostr/pubkeys`, {
const response = await fetch(`${API_BASE_URL}/api/v1/auth/nostr/pubkeys`, {
headers: {
'Authorization': `Bearer ${authToken}`,
'Content-Type': 'application/json'
@ -330,7 +430,6 @@ export class ChatService extends BaseService {
throw new Error(`Failed to load peers: ${response.status} - ${errorText}`)
}
const data = await response.json()
console.log('💬 API returned', data?.length || 0, 'peers')
if (!Array.isArray(data)) {
console.warn('💬 Invalid API response format - expected array, got:', typeof data)
return
@ -341,17 +440,35 @@ export class ChatService extends BaseService {
console.warn('💬 Skipping peer without pubkey:', peer)
return
}
const chatPeer: ChatPeer = {
pubkey: peer.pubkey,
name: peer.username || `User ${peer.pubkey.slice(0, 8)}`,
unreadCount: 0,
lastSeen: Date.now()
// CRITICAL: Skip current user - you can't chat with yourself!
if (currentUserPubkey && peer.pubkey === currentUserPubkey) {
return
}
// Check if peer already exists to preserve message history timestamps
const existingPeer = this.peers.value.get(peer.pubkey)
if (existingPeer) {
// Update name only if provided
if (peer.username && peer.username !== existingPeer.name) {
existingPeer.name = peer.username
}
} else {
// Create new peer with all required fields
const chatPeer: ChatPeer = {
pubkey: peer.pubkey,
name: peer.username || `User ${peer.pubkey.slice(0, 8)}`,
unreadCount: 0,
lastSent: 0,
lastReceived: 0,
lastChecked: 0
}
this.peers.value.set(peer.pubkey, chatPeer)
}
this.peers.value.set(peer.pubkey, chatPeer)
})
// Save to storage
this.savePeersToStorage()
console.log(`✅ Loaded ${data.length} peers from API, total peers now: ${this.peers.value.size}`)
} catch (error) {
console.error('❌ Failed to load peers from API:', error)
// Don't re-throw - peers from storage are still available
@ -366,9 +483,15 @@ export class ChatService extends BaseService {
}
try {
const peersArray = this.storageService.getUserData('chat-peers', []) as ChatPeer[]
console.log('💬 Loading', peersArray.length, 'peers from storage')
peersArray.forEach(peer => {
this.peers.value.set(peer.pubkey, peer)
// Migrate old peer structure to new structure with required fields
const migratedPeer: ChatPeer = {
...peer,
lastSent: peer.lastSent ?? 0,
lastReceived: peer.lastReceived ?? 0,
lastChecked: peer.lastChecked ?? 0
}
this.peers.value.set(peer.pubkey, migratedPeer)
})
} catch (error) {
console.warn('💬 Failed to load peers from storage:', error)
@ -396,10 +519,8 @@ export class ChatService extends BaseService {
}
const peerPubkeys = Array.from(this.peers.value.keys())
if (peerPubkeys.length === 0) {
console.log('No peers to load message history for')
return
return
}
console.log('Loading message history for', peerPubkeys.length, 'peers')
// Query historical messages (kind 4) to/from known peers
// We need separate queries for sent vs received messages due to different tagging
const receivedEvents = await this.relayHub.queryEvents([
@ -412,7 +533,7 @@ export class ChatService extends BaseService {
])
const sentEvents = await this.relayHub.queryEvents([
{
kinds: [4],
kinds: [4],
authors: [userPubkey], // Messages from us
'#p': peerPubkeys, // Messages tagged to peers
limit: 100
@ -420,15 +541,36 @@ export class ChatService extends BaseService {
])
const events = [...receivedEvents, ...sentEvents]
.sort((a, b) => a.created_at - b.created_at) // Sort by timestamp
console.log('Found', events.length, 'historical messages:', receivedEvents.length, 'received,', sentEvents.length, 'sent')
// CRITICAL: First pass - create all peers from message events BEFORE loading from API
const uniquePeerPubkeys = new Set<string>()
for (const event of events) {
const isFromUs = event.pubkey === userPubkey
const peerPubkey = isFromUs
? event.tags.find((tag: string[]) => tag[0] === 'p')?.[1]
: event.pubkey
if (peerPubkey && peerPubkey !== userPubkey) {
uniquePeerPubkeys.add(peerPubkey)
}
}
// Create peers from actual message senders
for (const peerPubkey of uniquePeerPubkeys) {
if (!this.peers.value.has(peerPubkey)) {
this.addPeer(peerPubkey)
}
}
// Process historical messages
for (const event of events) {
try {
const isFromUs = event.pubkey === userPubkey
const peerPubkey = isFromUs
const peerPubkey = isFromUs
? event.tags.find((tag: string[]) => tag[0] === 'p')?.[1] // Get recipient from tag
: event.pubkey // Sender is the peer
if (!peerPubkey || peerPubkey === userPubkey) continue
// Decrypt the message
const decryptedContent = await nip04.decrypt(userPrivkey, peerPubkey, event.content)
// Create a chat message
@ -439,13 +581,13 @@ export class ChatService extends BaseService {
sent: isFromUs,
pubkey: event.pubkey
}
// Add the message (will avoid duplicates)
this.addMessage(peerPubkey, message)
} catch (error) {
console.error('Failed to decrypt historical message:', error)
}
}
console.log('Message history loaded successfully')
} catch (error) {
console.error('Failed to load message history:', error)
}
@ -473,7 +615,6 @@ export class ChatService extends BaseService {
console.warn('💬 RelayHub not connected, waiting for connection...')
// Listen for connection event
this.relayHub.on('connected', () => {
console.log('💬 RelayHub connected, setting up message subscription...')
this.setupMessageSubscription()
})
// Also retry after timeout in case event is missed
@ -502,10 +643,8 @@ export class ChatService extends BaseService {
await this.processIncomingMessage(event)
},
onEose: () => {
console.log('💬 Chat message subscription EOSE received')
}
})
console.log('💬 Chat message subscription set up successfully for pubkey:', userPubkey.substring(0, 10) + '...')
} catch (error) {
console.error('💬 Failed to setup message subscription:', error)
// Retry after delay
@ -590,7 +729,6 @@ export class ChatService extends BaseService {
// Forward to market handler
if (this.marketMessageHandler) {
await this.marketMessageHandler(event)
console.log('💬 Market message forwarded to market handler and will also be added to chat')
} else {
console.warn('Market message handler not available, message will be treated as chat')
}
@ -633,7 +771,6 @@ export class ChatService extends BaseService {
this.addPeer(senderPubkey)
// Add the message
this.addMessage(senderPubkey, message)
console.log('Received encrypted chat message from:', senderPubkey.slice(0, 8))
}
} catch (error) {
console.error('Failed to process incoming message:', error)