alma/Neah
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

courrier multi account restore compose

Browse Source
This commit is contained in:
alma 2025-04-29 11:29:48 +02:00
parent 0368bd1069
commit 2fada01eba
4 changed files with 169 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
app/api/courrier/[id]/mark-read/route.ts
View File

@ -45,15 +45,24 @@ export async function POST(
const { folder = 'INBOX', accountId, isRead = true } = await request.json();
// Extract account ID from folder name if present and none was explicitly provided
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
// Log operation details for debugging
console.log(`Marking email ${emailId} as ${isRead ? 'read' : 'unread'} in folder ${folder}${accountId ? ` for account ${accountId}` : ''}`);
console.log(`Marking email ${emailId} as ${isRead ? 'read' : 'unread'} in folder ${normalizedFolder} for account ${effectiveAccountId}`);
const success = await markEmailReadStatus(
session.user.id,
emailId,
isRead,
folder,
accountId
normalizedFolder,
effectiveAccountId
);
if (!success) {

27
app/api/courrier/route.ts
View File

@ -37,31 +37,42 @@ export async function GET(request: Request) {
const searchQuery = searchParams.get("search") || "";
const accountId = searchParams.get("accountId") || "";
// Extract account ID from folder name if present and none was explicitly provided
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
// Log the request details for debugging
console.log(`Email request: user=${session.user.id}, folder=${normalizedFolder}, account=${effectiveAccountId}, page=${page}`);
// Try to get from Redis cache first, but only if it's not a search query
if (!searchQuery) {
const cacheKey = accountId ? `${session.user.id}:${accountId}:${folder}` : `${session.user.id}:${folder}`;
const cachedEmails = await getCachedEmailList(
session.user.id,
accountId || 'default',
folder,
effectiveAccountId,
normalizedFolder,
page,
perPage
);
if (cachedEmails) {
console.log(`Using Redis cached emails for ${cacheKey}:${page}:${perPage}`);
console.log(`Using Redis cached emails for ${session.user.id}:${effectiveAccountId}:${normalizedFolder}:${page}:${perPage}`);
return NextResponse.json(cachedEmails);
}
}
console.log(`Redis cache miss for ${session.user.id}:${folder}:${page}:${perPage}, fetching emails from IMAP`);
console.log(`Redis cache miss for ${session.user.id}:${effectiveAccountId}:${normalizedFolder}:${page}:${perPage}, fetching emails from IMAP`);
// Use the email service to fetch emails, passing the accountId if provided
// Use the email service to fetch emails with the normalized folder and effective account ID
const emailsResult = await getEmails(
session.user.id,
folder,
normalizedFolder,
page,
perPage,
accountId || undefined
effectiveAccountId
);
// The result is already cached in the getEmails function

77
hooks/use-courrier.ts
View File

@ -266,11 +266,22 @@ export const useCourrier = () => {
const changeFolder = useCallback(async (folder: string, accountId?: string) => {
console.log(`Changing folder to ${folder} for account ${accountId || 'default'}`);
try {
// Extract account ID from folder name if present and none was explicitly provided
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
console.log(`Folder change normalized: ${normalizedFolder}, account: ${effectiveAccountId}`);
// Reset selected email
setSelectedEmail(null);
setSelectedEmailIds([]);
// Record the new folder
// Record the new folder (preserving account prefix if present)
setCurrentFolder(folder);
// Reset search query when changing folders
@ -289,8 +300,8 @@ export const useCourrier = () => {
// This helps prevent race conditions when multiple folders are clicked quickly
await new Promise(resolve => setTimeout(resolve, 100));
// Call loadEmails with correct boolean parameter type
await loadEmails(false, accountId);
// Call loadEmails with correct boolean parameter type and account ID
await loadEmails(false, effectiveAccountId);
} catch (error) {
console.error(`Error changing to folder ${folder}:`, error);
setError(error instanceof Error ? error.message : 'Unknown error');
@ -323,11 +334,27 @@ export const useCourrier = () => {
// Fetch a single email's content
const fetchEmailContent = useCallback(async (emailId: string, accountId?: string, folderOverride?: string) => {
try {
// Use the provided folder or current folder
const folderToUse = folderOverride || currentFolder;
// Extract account ID from folder name if present and none was explicitly provided
const folderAccountId = folderToUse.includes(':') ? folderToUse.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folderToUse.includes(':') ? folderToUse.split(':')[1] : folderToUse;
console.log(`Fetching email content for ID ${emailId} from folder ${normalizedFolder}, account: ${effectiveAccountId}`);
const query = new URLSearchParams({
folder: folderToUse,
folder: normalizedFolder,
});
if (accountId) query.set('accountId', accountId);
// Always include account ID in query params
query.set('accountId', effectiveAccountId);
const response = await fetch(`/api/courrier/${emailId}?${query.toString()}`);
if (!response.ok) {
throw new Error(`Failed to fetch email content: ${response.status}`);
@ -350,7 +377,14 @@ export const useCourrier = () => {
}
// Get the accountId from the email
const emailAccountId = emailToMark.accountId;
const emailAccountId = emailToMark.accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = emailToMark.folder.includes(':')
? emailToMark.folder.split(':')[1]
: emailToMark.folder;
console.log(`Marking email ${emailId} as ${isRead ? 'read' : 'unread'} in folder ${normalizedFolder}, account: ${emailAccountId}`);
const response = await fetch(`/api/courrier/${emailId}/mark-read`, {
method: 'POST',
@ -359,7 +393,7 @@ export const useCourrier = () => {
},
body: JSON.stringify({
isRead,
folder: currentFolder,
folder: normalizedFolder,
accountId: emailAccountId
})
});
@ -383,20 +417,39 @@ export const useCourrier = () => {
console.error('Error marking email as read:', error);
return false;
}
}, [emails, selectedEmail, currentFolder]);
}, [emails, selectedEmail]);
// Select an email to view
const handleEmailSelect = useCallback(async (emailId: string, accountId: string, folderOverride: string) => {
console.log(`Selecting email ${emailId} from account ${accountId} in folder ${folderOverride}`);
setIsLoading(true);
try {
// Normalize account ID if not provided
const effectiveAccountId = accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folderOverride.includes(':') ? folderOverride.split(':')[1] : folderOverride;
// Find the email in the current list
const email = emails.find(e => e.id === emailId && e.accountId === accountId && e.folder === folderOverride);
const email = emails.find(e =>
e.id === emailId &&
(e.accountId === effectiveAccountId) &&
(e.folder === normalizedFolder || e.folder === folderOverride)
);
if (!email) {
throw new Error('Email not found');
console.log(`Email ${emailId} not found in current list. Fetching from API.`);
const fullEmail = await fetchEmailContent(emailId, effectiveAccountId, normalizedFolder);
setSelectedEmail(fullEmail);
return;
}
// If content is not fetched, get the full content
if (!email.contentFetched) {
const fullEmail = await fetchEmailContent(emailId, accountId, folderOverride);
console.log(`Fetching content for email ${emailId}`);
const fullEmail = await fetchEmailContent(emailId, effectiveAccountId, normalizedFolder);
// Merge the full content with the email
const updatedEmail = {
...email,
@ -404,12 +457,14 @@ export const useCourrier = () => {
attachments: fullEmail.attachments,
contentFetched: true
};
// Update the email in the list
setEmails(emails.map(e => e.id === emailId ? updatedEmail : e));
setSelectedEmail(updatedEmail);
} else {
setSelectedEmail(email);
}
// Mark the email as read if it's not already
if (!email.flags.seen) {
markEmailAsRead(emailId, true);

131
lib/services/email-service.ts
View File

@ -195,7 +195,7 @@ export async function getUserEmailCredentials(userId: string, accountId?: string
secure: mailCredentials.secure,
smtp_host: mailCredentials.smtp_host || undefined,
smtp_port: mailCredentials.smtp_port || undefined,
smtp_secure: mailCredentials.smtp_secure || false,
smtp_secure: mailCredentials.smtp_secure ?? false,
display_name: mailCredentials.display_name || undefined,
color: mailCredentials.color || undefined
};
@ -282,26 +282,33 @@ export async function getEmails(
let client: ImapFlow | undefined;
try {
// Extract the actual folder name (remove account prefix if present)
const actualFolder = folder.includes(':') ? folder.split(':')[1] : folder;
console.log(`Fetching emails for folder: ${folder} (actual: ${actualFolder})`);
// Extract account ID from folder name if present and none was explicitly provided
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
console.log(`[getEmails] Processing request for folder: ${folder}, normalized to ${normalizedFolder}, account: ${effectiveAccountId}`);
// Get IMAP connection
client = await getImapConnection(userId, accountId);
// Get IMAP connection using the effective account ID
client = await getImapConnection(userId, effectiveAccountId);
if (!client) {
throw new Error('Failed to establish IMAP connection');
}
// Open mailbox with the actual folder name
await client.mailboxOpen(actualFolder);
// Open mailbox with the normalized folder name
await client.mailboxOpen(normalizedFolder);
const mailbox = client.mailbox;
if (!mailbox || typeof mailbox === 'boolean') {
throw new Error(`Failed to open mailbox: ${actualFolder}`);
throw new Error(`Failed to open mailbox: ${normalizedFolder}`);
}
// Get total messages
const total = mailbox.exists || 0;
console.log(`Total messages in ${actualFolder}: ${total}`);
console.log(`Total messages in ${normalizedFolder} for account ${effectiveAccountId}: ${total}`);
// If no messages, return empty result
if (total === 0) {
@ -311,7 +318,7 @@ export async function getEmails(
page,
perPage,
totalPages: 0,
folder: actualFolder,
folder: normalizedFolder,
mailboxes: []
};
}
@ -319,7 +326,7 @@ export async function getEmails(
// Calculate message range for pagination
const start = Math.max(1, total - (page * perPage) + 1);
const end = Math.max(1, total - ((page - 1) * perPage));
console.log(`Fetching messages ${start}:${end} from ${actualFolder}`);
console.log(`Fetching messages ${start}:${end} from ${normalizedFolder} for account ${effectiveAccountId}`);
// Fetch messages
const messages = await client.fetch(`${start}:${end}`, {
@ -351,9 +358,9 @@ export async function getEmails(
},
size: message.size || 0,
hasAttachments: message.bodyStructure?.childNodes?.some(node => node.disposition === 'attachment') || false,
folder: actualFolder,
folder: normalizedFolder,
contentFetched: false,
accountId: accountId || 'default',
accountId: effectiveAccountId,
content: {
text: '',
html: ''
@ -362,18 +369,16 @@ export async function getEmails(
emails.push(email);
}
// Cache the result if we have an accountId
if (accountId) {
await cacheEmailList(userId, accountId, actualFolder, page, perPage, {
emails,
totalEmails: total,
page,
perPage,
totalPages: Math.ceil(total / perPage),
folder: actualFolder,
mailboxes: []
});
}
// Cache the result with the effective account ID
await cacheEmailList(userId, effectiveAccountId, normalizedFolder, page, perPage, {
emails,
totalEmails: total,
page,
perPage,
totalPages: Math.ceil(total / perPage),
folder: normalizedFolder,
mailboxes: []
});
return {
emails,
@ -381,7 +386,7 @@ export async function getEmails(
page,
perPage,
totalPages: Math.ceil(total / perPage),
folder: actualFolder,
folder: normalizedFolder,
mailboxes: []
};
} catch (error) {
@ -423,55 +428,60 @@ export async function getEmailContent(
throw new Error('Email ID must be a number');
}
// Remove accountId prefix if present in folder name
const actualFolder = folder.includes(':') ? folder.split(':')[1] : folder;
// Extract account ID from folder name if present and none was explicitly provided
const effectiveAccountId = folder.includes(':') && !accountId ? folder.split(':')[0] : accountId;
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use normalized folder name for cache key
const cacheKey = effectiveAccountId || 'default';
const cachedEmail = await getCachedEmailContent(userId, cacheKey, emailId);
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
console.log(`[getEmailContent] Fetching email ${emailId} from folder ${normalizedFolder}, account ${effectiveAccountId}`);
// Use normalized folder name and effective account ID for cache key
const cachedEmail = await getCachedEmailContent(userId, effectiveAccountId, emailId);
if (cachedEmail) {
console.log(`Using cached email content for ${userId}:${cacheKey}:${emailId}`);
console.log(`Using cached email content for ${userId}:${effectiveAccountId}:${emailId}`);
return cachedEmail;
}
console.log(`Cache miss for email content ${userId}:${cacheKey}:${emailId}, fetching from IMAP`);
console.log(`Cache miss for email content ${userId}:${effectiveAccountId}:${emailId}, fetching from IMAP`);
const client = await getImapConnection(userId, effectiveAccountId);
try {
// Log connection details with account context
console.log(`[DEBUG] Fetching email ${emailId} from folder ${actualFolder} for account ${effectiveAccountId || 'default'}`);
console.log(`[DEBUG] Fetching email ${emailId} from folder ${normalizedFolder} for account ${effectiveAccountId}`);
// Open mailbox with error handling
const mailbox = await client.mailboxOpen(actualFolder);
const mailbox = await client.mailboxOpen(normalizedFolder);
if (!mailbox || typeof mailbox === 'boolean') {
throw new Error(`Failed to open mailbox: ${actualFolder} for account ${effectiveAccountId || 'default'}`);
throw new Error(`Failed to open mailbox: ${normalizedFolder} for account ${effectiveAccountId}`);
}
// Log mailbox status with account context
console.log(`[DEBUG] Mailbox ${actualFolder} opened for account ${effectiveAccountId || 'default'}, total messages: ${mailbox.exists}`);
console.log(`[DEBUG] Mailbox ${normalizedFolder} opened for account ${effectiveAccountId}, total messages: ${mailbox.exists}`);
// Get the UIDVALIDITY and UIDNEXT values
const uidValidity = mailbox.uidValidity;
const uidNext = mailbox.uidNext;
console.log(`[DEBUG] Mailbox UIDVALIDITY: ${uidValidity}, UIDNEXT: ${uidNext} for account ${effectiveAccountId || 'default'}`);
console.log(`[DEBUG] Mailbox UIDVALIDITY: ${uidValidity}, UIDNEXT: ${uidNext} for account ${effectiveAccountId}`);
// Validate UID exists in mailbox
if (numericId >= uidNext) {
throw new Error(`Email ID ${numericId} is greater than or equal to the highest UID in mailbox (${uidNext}) for account ${effectiveAccountId || 'default'}`);
throw new Error(`Email ID ${numericId} is greater than or equal to the highest UID in mailbox (${uidNext}) for account ${effectiveAccountId}`);
}
// First, try to get the sequence number for this UID
const searchResult = await client.search({ uid: numericId.toString() });
if (!searchResult || searchResult.length === 0) {
throw new Error(`Email with UID ${numericId} not found in folder ${actualFolder} for account ${effectiveAccountId || 'default'}`);
throw new Error(`Email with UID ${numericId} not found in folder ${normalizedFolder} for account ${effectiveAccountId}`);
}
const sequenceNumber = searchResult[0];
console.log(`[DEBUG] Found sequence number ${sequenceNumber} for UID ${numericId} in account ${effectiveAccountId || 'default'}`);
console.log(`[DEBUG] Found sequence number ${sequenceNumber} for UID ${numericId} in account ${effectiveAccountId}`);
// Now fetch using the sequence number
const message = await client.fetchOne(sequenceNumber.toString(), {
@ -482,7 +492,7 @@ export async function getEmailContent(
});
if (!message) {
throw new Error(`Email not found with sequence number ${sequenceNumber} in folder ${actualFolder} for account ${effectiveAccountId || 'default'}`);
throw new Error(`Email not found with sequence number ${sequenceNumber} in folder ${normalizedFolder} for account ${effectiveAccountId}`);
}
const { source, envelope, flags, size } = message;
@ -537,21 +547,21 @@ export async function getEmailContent(
text: parsedEmail.text || '',
html: rawHtml || ''
},
folder: actualFolder,
folder: normalizedFolder,
contentFetched: true,
size: size || 0,
accountId: effectiveAccountId || 'default'
accountId: effectiveAccountId
};
// Cache the email content with account-specific key
await cacheEmailContent(userId, cacheKey, emailId, email);
// Cache the email content with effective account ID
await cacheEmailContent(userId, effectiveAccountId, emailId, email);
return email;
} catch (error) {
console.error('[ERROR] Email fetch failed:', {
userId,
emailId,
folder: actualFolder,
folder: normalizedFolder,
accountId: effectiveAccountId,
error: error instanceof Error ? error.message : 'Unknown error',
details: error instanceof Error ? error.stack : undefined
@ -576,15 +586,21 @@ export async function markEmailReadStatus(
folder: string = 'INBOX',
accountId?: string
): Promise<boolean> {
// Normalize folder name by removing account prefix if present
const actualFolder = folder.includes(':') ? folder.split(':')[1] : folder;
// Extract account ID from folder name if present and none was explicitly provided
const effectiveAccountId = folder.includes(':') && !accountId ? folder.split(':')[0] : accountId;
const folderAccountId = folder.includes(':') ? folder.split(':')[0] : accountId;
// Use the most specific account ID available
const effectiveAccountId = folderAccountId || accountId || 'default';
// Normalize folder name by removing account prefix if present
const normalizedFolder = folder.includes(':') ? folder.split(':')[1] : folder;
console.log(`[markEmailReadStatus] Marking email ${emailId} as ${isRead ? 'read' : 'unread'} in folder ${normalizedFolder}, account ${effectiveAccountId}`);
const client = await getImapConnection(userId, effectiveAccountId);
try {
await client.mailboxOpen(actualFolder);
await client.mailboxOpen(normalizedFolder);
if (isRead) {
await client.messageFlagsAdd(emailId, ['\\Seen']);
@ -592,18 +608,15 @@ export async function markEmailReadStatus(
await client.messageFlagsRemove(emailId, ['\\Seen']);
}
// Use normalized cacheKey for consistency
const cacheKey = effectiveAccountId || 'default';
// Invalidate content cache since the flags changed
await invalidateEmailContentCache(userId, cacheKey, emailId);
await invalidateEmailContentCache(userId, effectiveAccountId, emailId);
// Also invalidate folder cache because unread counts may have changed
await invalidateFolderCache(userId, cacheKey, actualFolder);
await invalidateFolderCache(userId, effectiveAccountId, normalizedFolder);
return true;
} catch (error) {
console.error(`Error marking email ${emailId} as ${isRead ? 'read' : 'unread'}:`, error);
console.error(`Error marking email ${emailId} as ${isRead ? 'read' : 'unread'} in folder ${normalizedFolder}, account ${effectiveAccountId}:`, error);
return false;
} finally {
try {