starred/native
1
0
Fork 0
mirror of https://github.com/bulwarkmail/native.git synced 2026-10-31 08:06:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: show shared mailboxes (group accounts) in the sidebar #37

Browse Source
This commit is contained in:
Linus Rath
2026-08-02 20:17:29 +02:00
parent 5c775ad82e
commit be82bfe814
23 changed files with 1204 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/api/__tests__/email.test.ts
+99 -1
View File
@@ -5,12 +5,16 @@ vi.mock('../jmap-client', () => ({
jmapClient: {
accountId: 'acc-1',
request: vi.fn(),
getAccountName: vi.fn(() => 'me@example.com'),
getSharedMailAccounts: vi.fn(() => []),
getMaxCallsInRequest: vi.fn(() => 16),
},
}));
import { jmapClient } from '../jmap-client';
import {
getMailboxes,
getSharedMailboxes,
queryEmails,
getEmails,
getFullEmail,
@@ -41,13 +45,107 @@ describe('email operations', () => {
const result = await getMailboxes();
expect(result).toEqual(mailboxes);
// Own folders keep their raw ids and pick up ownership metadata.
expect(result).toEqual(mailboxes.map((m) => ({
...m,
accountId: 'acc-1',
accountName: 'me@example.com',
isShared: false,
})));
expect(mockRequest).toHaveBeenCalledWith(
[['Mailbox/get', { accountId: 'acc-1' }, '0']],
);
});
});
describe('getSharedMailboxes', () => {
const mockShared = jmapClient.getSharedMailAccounts as ReturnType<typeof vi.fn>;
it('returns nothing when the session has no shared accounts', async () => {
mockShared.mockReturnValue([]);
expect(await getSharedMailboxes()).toEqual([]);
expect(mockRequest).not.toHaveBeenCalled();
});
it('prefixes ids and parent links per owning account', async () => {
mockShared.mockReturnValue([{ id: 'grp-1', name: 'Support' }]);
mockRequest.mockResolvedValue({
methodResponses: [['Mailbox/get', {
list: [
{ id: 'mb-1', name: 'Inbox', role: 'inbox', totalEmails: 4, unreadEmails: 2 },
{ id: 'mb-2', name: 'Escalations', parentId: 'mb-1', totalEmails: 1, unreadEmails: 0 },
],
}, '0']],
});
const result = await getSharedMailboxes();
expect(mockRequest).toHaveBeenCalledWith(
[['Mailbox/get', { accountId: 'grp-1' }, '0']],
);
expect(result).toEqual([
{
id: 'grp-1:mb-1',
originalId: 'mb-1',
name: 'Inbox',
role: 'inbox',
parentId: undefined,
totalEmails: 4,
unreadEmails: 2,
accountId: 'grp-1',
accountName: 'Support',
isShared: true,
},
{
id: 'grp-1:mb-2',
originalId: 'mb-2',
name: 'Escalations',
parentId: 'grp-1:mb-1',
totalEmails: 1,
unreadEmails: 0,
accountId: 'grp-1',
accountName: 'Support',
isShared: true,
},
]);
});
it('maps each response back to its account and skips the ones that errored', async () => {
mockShared.mockReturnValue([
{ id: 'grp-1', name: 'Support' },
{ id: 'grp-2', name: 'Sales' },
]);
mockRequest.mockResolvedValue({
methodResponses: [
['error', { type: 'accountNotFound' }, '0'],
['Mailbox/get', { list: [{ id: 'mb-9', name: 'Inbox', role: 'inbox' }] }, '1'],
],
});
const result = await getSharedMailboxes();
expect(result.map((m) => m.id)).toEqual(['grp-2:mb-9']);
expect(result[0].accountName).toBe('Sales');
});
it('chunks requests to maxCallsInRequest', async () => {
mockShared.mockReturnValue([
{ id: 'grp-1', name: 'Support' },
{ id: 'grp-2', name: 'Sales' },
{ id: 'grp-3', name: 'Billing' },
]);
(jmapClient.getMaxCallsInRequest as ReturnType<typeof vi.fn>).mockReturnValue(2);
mockRequest.mockResolvedValue({ methodResponses: [] });
await getSharedMailboxes();
expect(mockRequest).toHaveBeenCalledTimes(2);
expect(mockRequest.mock.calls[0][0]).toHaveLength(2);
expect(mockRequest.mock.calls[1][0]).toHaveLength(1);
});
});
describe('queryEmails', () => {
it('should query emails with default options', async () => {
mockRequest.mockResolvedValue({
src/api/blob.ts
+6 -2
View File
@@ -67,13 +67,17 @@ export async function uploadBlob(
export async function uploadBytes(
bytes: Uint8Array,
type: string,
// Blobs are account-scoped: a message imported into a shared/group account's
// folder has to be uploaded to that account, not the user's own.
accountId?: string,
): Promise<{ blobId: string; size: number; type: string }> {
const session = jmapClient.currentSession;
if (!session) throw new Error('Not connected');
const targetAccountId = accountId ?? jmapClient.accountId;
const uploadUrl = session.uploadUrl.replace(
'{accountId}',
encodeURIComponent(jmapClient.accountId),
encodeURIComponent(targetAccountId),
);
const response = await secureFetch(uploadUrl, {
@@ -99,7 +103,7 @@ export async function uploadBytes(
type: typeof direct.type === 'string' && direct.type ? direct.type : type,
};
}
const nested = raw[jmapClient.accountId] as
const nested = raw[targetAccountId] as
| { blobId?: string; type?: string; size?: number }
| undefined;
if (nested?.blobId) {
src/api/email.ts
+146 -44
View File
@@ -14,33 +14,112 @@ const EMAIL_FULL_PROPERTIES = [
'attachments', 'blobId', 'bcc', 'replyTo', 'sentAt',
];
export async function getMailboxes(): Promise<Mailbox[]> {
const accountId = jmapClient.accountId;
const res = await jmapClient.request(
[['Mailbox/get', { accountId }, '0']],
);
return res.methodResponses[0][1].list;
// Prefix a shared account's folder ids so they can't collide with the user's
// own. Matches the webmail's `${accountId}:${mailboxId}` scheme.
function sharedMailboxId(accountId: string, rawId: string): string {
return `${accountId}:${rawId}`;
}
/** Inverse of {@link sharedMailboxId}; a no-op for the user's own folders. */
export function unprefixMailboxId(id: string, accountId?: string): string {
if (!accountId) return id;
const prefix = `${accountId}:`;
return id.startsWith(prefix) ? id.slice(prefix.length) : id;
}
// Stamp ownership onto a raw Mailbox/get result. Own folders keep their raw
// ids; a shared account's are prefixed and remember their `originalId` so
// server calls can still address them.
function tagMailbox(
mailbox: Mailbox,
accountId: string,
accountName: string | undefined,
isShared: boolean,
): Mailbox {
if (!isShared) {
return { ...mailbox, accountId, accountName, isShared: false };
}
return {
...mailbox,
id: sharedMailboxId(accountId, mailbox.id),
originalId: mailbox.id,
parentId: mailbox.parentId ? sharedMailboxId(accountId, mailbox.parentId) : mailbox.parentId,
accountId,
accountName,
isShared: true,
};
}
export async function getMailboxes(accountId?: string): Promise<Mailbox[]> {
return (await getMailboxesWithState(accountId)).list;
}
// Variant that also returns the JMAP `state` token so callers can later issue
// Mailbox/changes(sinceState=…) to fetch only what changed.
export async function getMailboxesWithState(): Promise<{ list: Mailbox[]; state: string }> {
const accountId = jmapClient.accountId;
export async function getMailboxesWithState(
accountIdOverride?: string,
): Promise<{ list: Mailbox[]; state: string }> {
const accountId = accountIdOverride ?? jmapClient.accountId;
const isShared = accountId !== jmapClient.accountId;
const res = await jmapClient.request(
[['Mailbox/get', { accountId }, '0']],
);
const body = res.methodResponses[0][1];
return { list: body.list as Mailbox[], state: body.state as string };
const list = ((body.list as Mailbox[]) ?? []).map((m) =>
tagMailbox(m, accountId, jmapClient.getAccountName(accountId), isShared),
);
return { list, state: body.state as string };
}
export async function getMailboxesByIds(ids: string[]): Promise<{ list: Mailbox[]; state: string }> {
/**
* Every folder of every shared/group account in this session, ready to merge
* into the sidebar next to the user's own. One request carrying a Mailbox/get
* per account, chunked to the server's maxCallsInRequest. An account that
* errors (revoked access, server hiccup) is skipped rather than sinking the
* whole list.
*/
export async function getSharedMailboxes(): Promise<Mailbox[]> {
const accounts = jmapClient.getSharedMailAccounts();
if (accounts.length === 0) return [];
const perRequest = Math.max(1, jmapClient.getMaxCallsInRequest());
const out: Mailbox[] = [];
for (let i = 0; i < accounts.length; i += perRequest) {
const chunk = accounts.slice(i, i + perRequest);
const res = await jmapClient.request(
chunk.map((acc, idx): JMAPMethodCall => [
'Mailbox/get',
{ accountId: acc.id },
String(idx),
]),
);
for (const [name, body, callId] of res.methodResponses) {
if (name !== 'Mailbox/get') continue;
const acc = chunk[Number(callId)];
if (!acc) continue;
for (const m of (body.list as Mailbox[]) ?? []) {
out.push(tagMailbox(m, acc.id, acc.name, true));
}
}
}
return out;
}
export async function getMailboxesByIds(
ids: string[],
accountIdOverride?: string,
): Promise<{ list: Mailbox[]; state: string }> {
if (ids.length === 0) return { list: [], state: '' };
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const isShared = accountId !== jmapClient.accountId;
const res = await jmapClient.request(
[['Mailbox/get', { accountId, ids }, '0']],
);
const body = res.methodResponses[0][1];
return { list: body.list as Mailbox[], state: body.state as string };
const list = ((body.list as Mailbox[]) ?? []).map((m) =>
tagMailbox(m, accountId, jmapClient.getAccountName(accountId), isShared),
);
return { list, state: body.state as string };
}
export interface MailboxChangesResult {
@@ -54,8 +133,11 @@ export interface MailboxChangesResult {
// Returns null when the server can't compute the diff (typically
// `cannotCalculateChanges`); callers should fall back to a full Mailbox/get.
export async function getMailboxChanges(sinceState: string): Promise<MailboxChangesResult | null> {
const accountId = jmapClient.accountId;
export async function getMailboxChanges(
sinceState: string,
accountIdOverride?: string,
): Promise<MailboxChangesResult | null> {
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request(
[['Mailbox/changes', { accountId, sinceState }, '0']],
);
@@ -73,8 +155,9 @@ export async function getMailboxChanges(sinceState: string): Promise<MailboxChan
export async function createMailbox(
data: { name: string; parentId?: string | null },
accountIdOverride?: string,
): Promise<string> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const cid = 'new-mailbox';
const res = await jmapClient.request([
['Mailbox/set', {
@@ -102,8 +185,9 @@ export async function createMailbox(
export async function updateMailbox(
id: string,
changes: { name?: string; parentId?: string | null },
accountIdOverride?: string,
): Promise<void> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Mailbox/set', { accountId, update: { [id]: changes } }, '0'],
]);
@@ -117,8 +201,8 @@ export async function updateMailbox(
}
}
export async function deleteMailbox(id: string): Promise<void> {
const accountId = jmapClient.accountId;
export async function deleteMailbox(id: string, accountIdOverride?: string): Promise<void> {
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Mailbox/set', { accountId, destroy: [id] }, '0'],
]);
@@ -155,9 +239,11 @@ export async function queryEmails(
limit?: number;
sort?: Array<{ property: string; isAscending: boolean }>;
filter?: Record<string, unknown>;
/** Owning JMAP account when the mailbox belongs to a shared account. */
accountId?: string;
},
): Promise<{ ids: string[]; total: number; queryState?: string }> {
const accountId = jmapClient.accountId;
const accountId = options?.accountId ?? jmapClient.accountId;
const filter = buildMailboxQueryFilter(mailboxId, options?.filter);
const res = await jmapClient.request([
['Email/query', {
@@ -196,9 +282,11 @@ export async function getEmailQueryChanges(
filter?: Record<string, unknown>;
upToId?: string;
maxChanges?: number;
/** Owning JMAP account when the mailbox belongs to a shared account. */
accountId?: string;
},
): Promise<EmailQueryChangesResult | null> {
const accountId = jmapClient.accountId;
const accountId = options?.accountId ?? jmapClient.accountId;
const filter = buildMailboxQueryFilter(mailboxId, options?.filter);
const args: Record<string, unknown> = {
accountId,
@@ -222,8 +310,8 @@ export async function getEmailQueryChanges(
};
}
export async function getEmails(ids: string[]): Promise<Email[]> {
const accountId = jmapClient.accountId;
export async function getEmails(ids: string[], accountIdOverride?: string): Promise<Email[]> {
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Email/get', { accountId, ids, properties: EMAIL_LIST_PROPERTIES }, '0'],
]);
@@ -233,18 +321,21 @@ export async function getEmails(ids: string[]): Promise<Email[]> {
// Returns the Email/get response with the JMAP `state` token. Used by the
// store so we can later issue Email/changes(sinceState=…) for incremental
// updates instead of re-fetching the full list.
export async function getEmailsWithState(ids: string[]): Promise<{ list: Email[]; state: string }> {
export async function getEmailsWithState(
ids: string[],
accountIdOverride?: string,
): Promise<{ list: Email[]; state: string }> {
if (ids.length === 0) {
// Email/get with an empty id list still returns a state token; useful for
// priming the store after an empty mailbox query.
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Email/get', { accountId, ids: [], properties: EMAIL_LIST_PROPERTIES }, '0'],
]);
const body = res.methodResponses[0][1];
return { list: [], state: body.state as string };
}
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Email/get', { accountId, ids, properties: EMAIL_LIST_PROPERTIES }, '0'],
]);
@@ -266,8 +357,9 @@ export interface EmailChangesResult {
export async function getEmailChanges(
sinceState: string,
maxChanges?: number,
accountIdOverride?: string,
): Promise<EmailChangesResult | null> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const args: Record<string, unknown> = { accountId, sinceState };
if (maxChanges) args.maxChanges = maxChanges;
const res = await jmapClient.request([['Email/changes', args, '0']]);
@@ -306,9 +398,9 @@ export async function getFullEmail(id: string, accountIdOverride?: string): Prom
// Batch variant for offline sync. JMAP servers cap how many objects can be
// returned in a single Email/get; the caller should chunk to that ceiling
// (the client exposes maxObjectsInGet via getMaxObjectsInGet()).
export async function getFullEmails(ids: string[]): Promise<Email[]> {
export async function getFullEmails(ids: string[], accountIdOverride?: string): Promise<Email[]> {
if (ids.length === 0) return [];
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Email/get', {
accountId,
@@ -332,8 +424,9 @@ export async function importEmailBlob(
blobId: string,
mailboxId: string,
keywords: Record<string, boolean> = { $seen: true },
accountIdOverride?: string,
): Promise<string> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request([
['Email/import', {
accountId,
@@ -352,8 +445,8 @@ export async function importEmailBlob(
return id;
}
export async function getThread(threadId: string): Promise<Thread> {
const accountId = jmapClient.accountId;
export async function getThread(threadId: string, accountIdOverride?: string): Promise<Thread> {
const accountId = accountIdOverride ?? jmapClient.accountId;
const res = await jmapClient.request(
[['Thread/get', { accountId, ids: [threadId] }, '0']],
);
@@ -375,8 +468,9 @@ export async function moveEmail(
emailId: string,
fromMailboxId: string,
toMailboxId: string,
accountIdOverride?: string,
): Promise<void> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
await jmapClient.request([
['Email/set', {
accountId,
@@ -395,9 +489,10 @@ export async function moveEmails(
ids: string[],
fromMailboxId: string,
toMailboxId: string,
accountIdOverride?: string,
): Promise<void> {
if (ids.length === 0) return;
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const update: Record<string, Record<string, unknown>> = {};
for (const id of ids) {
update[id] = {
@@ -413,22 +508,24 @@ export async function deleteEmails(
ids: string[],
trashMailboxId: string,
currentMailboxId: string,
accountIdOverride?: string,
): Promise<void> {
if (ids.length === 0) return;
if (currentMailboxId === trashMailboxId) {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
await jmapClient.request([['Email/set', { accountId, destroy: ids }, '0']]);
} else {
await moveEmails(ids, currentMailboxId, trashMailboxId);
await moveEmails(ids, currentMailboxId, trashMailboxId, accountIdOverride);
}
}
// Apply keyword maps to several emails in one round-trip.
export async function setKeywordsForEmails(
updates: Array<{ id: string; keywords: Record<string, boolean> }>,
accountIdOverride?: string,
): Promise<void> {
if (updates.length === 0) return;
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const update: Record<string, { keywords: Record<string, boolean> }> = {};
for (const u of updates) update[u.id] = { keywords: u.keywords };
await jmapClient.request([['Email/set', { accountId, update }, '0']]);
@@ -439,9 +536,10 @@ export async function setKeywordsForEmails(
// the entire map, so we don't need to compute a diff against the current state.
export async function restoreEmailMailboxes(
items: Array<{ id: string; mailboxIds: Record<string, boolean> }>,
accountIdOverride?: string,
): Promise<void> {
if (items.length === 0) return;
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const update: Record<string, { mailboxIds: Record<string, true> }> = {};
for (const item of items) {
const onlyTrue: Record<string, true> = {};
@@ -462,15 +560,16 @@ export async function restoreEmailMailboxes(
export async function setEmailMailboxes(
emailId: string,
mailboxIds: Record<string, boolean>,
accountIdOverride?: string,
): Promise<void> {
await restoreEmailMailboxes([{ id: emailId, mailboxIds }]);
await restoreEmailMailboxes([{ id: emailId, mailboxIds }], accountIdOverride);
}
// Permanently destroy emails (no move-to-trash). Idempotent: destroying an
// already-gone id is a no-op on replay.
export async function destroyEmails(ids: string[]): Promise<void> {
export async function destroyEmails(ids: string[], accountIdOverride?: string): Promise<void> {
if (ids.length === 0) return;
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
await jmapClient.request([['Email/set', { accountId, destroy: ids }, '0']]);
}
@@ -482,9 +581,10 @@ export async function archiveEmails(
archiveMailboxId: string,
mode: 'single' | 'year' | 'month',
existingMailboxes: Mailbox[],
accountIdOverride?: string,
): Promise<void> {
if (emails.length === 0) return;
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
if (mode === 'single') {
const updates = Object.fromEntries(
@@ -595,14 +695,15 @@ export async function deleteEmail(
emailId: string,
trashMailboxId: string,
currentMailboxId: string,
accountIdOverride?: string,
): Promise<void> {
if (currentMailboxId === trashMailboxId) {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
await jmapClient.request([
['Email/set', { accountId, destroy: [emailId] }, '0'],
]);
} else {
await moveEmail(emailId, currentMailboxId, trashMailboxId);
await moveEmail(emailId, currentMailboxId, trashMailboxId, accountIdOverride);
}
}
@@ -610,8 +711,9 @@ export async function searchEmails(
query: string,
mailboxId?: string,
limit = 30,
accountIdOverride?: string,
): Promise<string[]> {
const accountId = jmapClient.accountId;
const accountId = accountIdOverride ?? jmapClient.accountId;
const filter: Record<string, unknown> = { text: toWildcardQuery(query) };
if (mailboxId) filter.inMailbox = mailboxId;
src/api/jmap-client.ts
+48 -4
View File
@@ -459,6 +459,43 @@ export class JMAPClient {
return core?.maxObjectsInGet || 500;
}
getMaxCallsInRequest(): number {
const core = this.session?.capabilities?.[CAPABILITIES.CORE] as
| { maxCallsInRequest?: number }
| undefined;
return core?.maxCallsInRequest || 16;
}
// ── Shared / group accounts ───────────────────────────
// A JMAP session lists every account the credentials can reach: the user's
// own, plus any shared/group accounts (Stalwart "group accounts") they are a
// member of. Non-personal accounts are the shared mailboxes.
/**
* Mail-capable accounts other than the primary one. Stalwart doesn't always
* populate `accountCapabilities` on shared accounts, so an account counts as
* mail-capable when it advertises the mail capability OR is non-personal —
* the same rule the webmail's getSharedAccounts() applies.
*/
getSharedMailAccounts(): { id: string; name: string }[] {
if (!this.session || !this._accountId) return [];
const primaryId = this._accountId;
const out: { id: string; name: string }[] = [];
for (const [id, info] of Object.entries(this.session.accounts ?? {})) {
if (id === primaryId) continue;
const advertisesMail = info.accountCapabilities
? CAPABILITIES.MAIL in info.accountCapabilities
: false;
if (!advertisesMail && info.isPersonal) continue;
out.push({ id, name: info.name || id });
}
return out;
}
getAccountName(accountId: string): string | undefined {
return this.session?.accounts?.[accountId]?.name;
}
// ── Scheduled send (FUTURERELEASE) ────────────────────
// The JMAP submission capability advertises `maxDelayedSend` (max hold in
// seconds) and a `submissionExtensions` map; FUTURERELEASE support is what
@@ -515,19 +552,26 @@ export class JMAPClient {
// ── Blob Download ─────────────────────────────────────
// Expand the RFC 6570 level-1 template the JMAP server advertises.
getBlobDownloadUrl(blobId: string, name?: string, type?: string): string {
// `accountId` targets a shared/group account, whose blobs aren't reachable
// through the user's own account id.
getBlobDownloadUrl(blobId: string, name?: string, type?: string, accountId?: string): string {
if (!this.session?.downloadUrl) {
throw new Error('Download URL not available - not connected');
}
return this.session.downloadUrl
.replace('{accountId}', encodeURIComponent(this.accountId))
.replace('{accountId}', encodeURIComponent(accountId ?? this.accountId))
.replace('{blobId}', encodeURIComponent(blobId))
.replace('{name}', encodeURIComponent(name || 'download'))
.replace('{type}', encodeURIComponent(type || 'application/octet-stream'));
}
async fetchBlobArrayBuffer(blobId: string, name?: string, type?: string): Promise<ArrayBuffer> {
const url = this.getBlobDownloadUrl(blobId, name, type);
async fetchBlobArrayBuffer(
blobId: string,
name?: string,
type?: string,
accountId?: string,
): Promise<ArrayBuffer> {
const url = this.getBlobDownloadUrl(blobId, name, type, accountId);
await this.ensureFreshToken();
const doFetch = () => secureFetch(url, { headers: { Authorization: this.authHeader } });
let response = await doFetch();
src/api/types.ts
+14
View File
@@ -99,7 +99,15 @@ export interface MailboxRights {
}
export interface Mailbox {
/**
* Unique within the app. For the user's own folders this is the raw JMAP id;
* for a shared (group) account's folders it's `<accountId>:<rawId>` so ids
* from different accounts can't collide. Use `originalId` when talking to
* the server. Mirrors the webmail's scheme in [lib/jmap/client.ts].
*/
id: string;
/** Raw JMAP id — set only on shared folders, where `id` carries a prefix. */
originalId?: string;
name: string;
parentId?: string | null;
role?: string | null;
@@ -110,6 +118,12 @@ export interface Mailbox {
unreadThreads: number;
myRights: MailboxRights;
isSubscribed?: boolean;
/** JMAP account the folder lives under (primary or a shared/group account). */
accountId?: string;
/** Display name of the owning account, used as the sidebar group header. */
accountName?: string;
/** True when the folder belongs to a shared/group account, not the user. */
isShared?: boolean;
}
export interface Thread {
src/components/EmailBodyView.tsx
+9 -3
View File
@@ -27,6 +27,8 @@ function arrayBufferToBase64(buffer: ArrayBuffer): string {
interface EmailBodyViewProps {
email: Email;
senderEmail?: string;
/** Owning account when the message lives in a shared/group mailbox. */
jmapAccountId?: string;
// The body is a native WebView, which on Android swallows horizontal touches
// before the surrounding pager can see them. We detect a clear horizontal
// swipe inside the page and report it here so the pager can change messages.
@@ -457,7 +459,9 @@ const PINCH_ZOOM = `
})();
`;
export default function EmailBodyView({ email, senderEmail, onSwipe, onZoomChange }: EmailBodyViewProps) {
export default function EmailBodyView({
email, senderEmail, jmapAccountId, onSwipe, onZoomChange,
}: EmailBodyViewProps) {
const c = useColors();
const styles = React.useMemo(() => makeStyles(c), [c]);
const externalContentPolicy = useSettingsStore((s) => s.externalContentPolicy);
@@ -561,7 +565,9 @@ export default function EmailBodyView({ email, senderEmail, onSwipe, onZoomChang
await Promise.all(
toFetch.map(async ({ ref, att }) => {
try {
const buf = await jmapClient.fetchBlobArrayBuffer(att.blobId, att.name, att.type);
const buf = await jmapClient.fetchBlobArrayBuffer(
att.blobId, att.name, att.type, jmapAccountId,
);
if (cancelled) return;
const b64 = arrayBufferToBase64(buf);
next[ref] = `data:${att.type || 'application/octet-stream'};base64,${b64}`;
@@ -575,7 +581,7 @@ export default function EmailBodyView({ email, senderEmail, onSwipe, onZoomChang
}
})();
return () => { cancelled = true; };
}, [rawHtml, email.attachments]);
}, [rawHtml, email.attachments, jmapAccountId]);
const source = React.useMemo(() => {
if (rawHtml) {
src/components/MoveSheet.tsx
+3 -1
View File
@@ -98,7 +98,9 @@ export function MoveSheet({
{visibleNodes.map((node) => {
const Icon = moveTargetIcon(node.role, node.name);
const isCurrent = node.id === currentMailboxId;
const canTarget = node.myRights?.mayAddItems !== false && !isCurrent;
// A shared account's header is a grouping row, not a folder.
const canTarget =
!node.isAccountNode && node.myRights?.mayAddItems !== false && !isCurrent;
return (
<Pressable
key={node.id}
src/components/SidebarDrawer.tsx
+34 -7
View File
@@ -8,7 +8,7 @@ import { SafeAreaView } from 'react-native-safe-area-context';
import {
Inbox, Send, File as FileIcon, Trash2, Ban, Archive, Star,
Folder, FolderOpen, ChevronDown, ChevronRight, X, Settings, LogOut, Check, Plus,
Clock, Layers,
Clock, Layers, Users,
} from 'lucide-react-native';
import type { LucideIcon } from 'lucide-react-native';
import { spacing, radius, typography, type ThemePalette } from '../theme/tokens';
@@ -83,6 +83,8 @@ interface SidebarRowProps {
label: string;
depth: number;
isSelected: boolean;
/** Header for a shared/group account: styled as a section, never selected. */
isAccountHeader?: boolean;
unread: number;
total: number;
hasChildren: boolean;
@@ -92,7 +94,7 @@ interface SidebarRowProps {
}
function SidebarRow({
icon, label, depth, isSelected, unread, total,
icon, label, depth, isSelected, isAccountHeader, unread, total,
hasChildren, isExpanded, onPress, onToggleExpand,
}: SidebarRowProps) {
const c = useColors();
@@ -126,7 +128,11 @@ function SidebarRow({
</View>
<View style={styles.rowIcon}>{icon}</View>
<Text
style={[styles.rowLabel, isSelected && styles.rowLabelSelected]}
style={[
styles.rowLabel,
isSelected && styles.rowLabelSelected,
isAccountHeader && styles.rowLabelAccount,
]}
numberOfLines={1}
>
{label}
@@ -467,20 +473,34 @@ export default function SidebarDrawer({ visible, onClose }: SidebarDrawerProps)
visibleNodes.map((node) => {
const hasChildren = node.children.length > 0;
const isExpanded = expandedFolders.has(node.id);
const Icon = iconFor(node.role, node.name, hasChildren, isExpanded);
const isSelected = node.id === currentMailboxId;
// A shared/group account's header has no mailbox behind it —
// tapping it only opens or closes that account's folders.
const Icon = node.isAccountNode
? Users
: iconFor(node.role, node.name, hasChildren, isExpanded);
const isSelected = !node.isAccountNode && node.id === currentMailboxId;
return (
<SidebarRow
key={node.id}
icon={<Icon size={16} color={iconColor(c, node.role, isSelected)} />}
icon={
<Icon
size={16}
color={node.isAccountNode ? c.textMuted : iconColor(c, node.role, isSelected)}
/>
}
label={node.name}
depth={node.depth}
isSelected={isSelected}
isAccountHeader={node.isAccountNode}
unread={node.unreadEmails}
total={node.totalEmails}
hasChildren={hasChildren}
isExpanded={isExpanded}
onPress={() => handleSelect(node.id)}
onPress={
node.isAccountNode
? () => toggleExpand(node.id)
: () => handleSelect(node.id)
}
onToggleExpand={() => toggleExpand(node.id)}
/>
);
@@ -741,6 +761,13 @@ function makeStyles(c: ThemePalette) {
...typography.bodySemibold,
color: c.text,
},
rowLabelAccount: {
...typography.caption,
fontWeight: '600',
textTransform: 'uppercase',
letterSpacing: 0.5,
color: c.textSecondary,
},
counts: {
flexDirection: 'row',
alignItems: 'baseline',
src/components/settings/FilterSettings.tsx
+5 -1
View File
@@ -12,6 +12,7 @@ import { useSettingsStore } from '../../stores/settings-store';
import { useFilterStore } from '../../stores/filter-store';
import { useVacationStore } from '../../stores/vacation-store';
import { useEmailStore } from '../../stores/email-store';
import { ownMailboxes } from '../../lib/mailbox-tree';
import { useLocaleStore } from '../../stores/locale-store';
import { FilterRuleModal } from '../filters/FilterRuleModal';
import { SieveEditorSheet } from '../filters/SieveEditorSheet';
@@ -48,7 +49,10 @@ export function FilterSettings() {
const expandedView = useSettingsStore((s) => s.filtersExpandedView);
const updateSetting = useSettingsStore((s) => s.updateSetting);
const mailboxes = useEmailStore((s) => s.mailboxes);
// Sieve rules run on the user's own account, so only own folders are
// valid "file into" targets.
const allMailboxes = useEmailStore((s) => s.mailboxes);
const mailboxes = useMemo(() => ownMailboxes(allMailboxes), [allMailboxes]);
const vacationEnabled = useVacationStore((s) => s.isEnabled);
const {
src/components/settings/FolderSettings.tsx
+5 -1
View File
@@ -18,6 +18,7 @@ import { SettingsSection } from './settings-section';
import Button from '../Button';
import { spacing, radius, typography, type ThemePalette } from '../../theme/tokens';
import { useColors } from '../../theme/colors';
import { ownMailboxes } from '../../lib/mailbox-tree';
import { useEmailStore } from '../../stores/email-store';
import { createMailbox, updateMailbox, deleteMailbox } from '../../api/email';
import type { Mailbox } from '../../api/types';
@@ -43,7 +44,10 @@ type Editor =
export function FolderSettings() {
const c = useColors();
const styles = React.useMemo(() => makeStyles(c), [c]);
const mailboxes = useEmailStore((s) => s.mailboxes);
// Folder management (create/rename/delete) targets the user's own account;
// shared (group account) folders are read-only here.
const allMailboxes = useEmailStore((s) => s.mailboxes);
const mailboxes = React.useMemo(() => ownMailboxes(allMailboxes), [allMailboxes]);
const fetchMailboxes = useEmailStore((s) => s.fetchMailboxes);
const [editor, setEditor] = useState<Editor | null>(null);
src/components/settings/ReadingSettings.tsx
+4 -2
View File
@@ -14,6 +14,7 @@ import {
} from '../../stores/settings-store';
import { useEmailStore } from '../../stores/email-store';
import { archiveEmails, queryEmails, getEmails } from '../../api/email';
import { ownMailboxes } from '../../lib/mailbox-tree';
function MailLayoutPreview({ value }: { value: MailLayout }) {
const c = useColors();
@@ -103,7 +104,8 @@ export function ReadingSettings() {
const handleReorganizeArchive = async () => {
const { mailboxes, fetchMailboxes } = useEmailStore.getState();
const archiveMailbox = mailboxes.find(
// Reorganising runs against the user's own archive only.
const archiveMailbox = ownMailboxes(mailboxes).find(
(m) => m.role === 'archive' || m.name.toLowerCase() === 'archive',
);
if (!archiveMailbox) {
@@ -130,7 +132,7 @@ export function ReadingSettings() {
if (ids.length === 0) break;
const list = await getEmails(ids);
const refreshed = useEmailStore.getState().mailboxes;
const refreshed = ownMailboxes(useEmailStore.getState().mailboxes);
await archiveEmails(
list.map((e) => ({ id: e.id, receivedAt: e.receivedAt })),
archiveMailbox.id,
src/lib/__tests__/mailbox-tree.test.ts
+142
View File
@@ -0,0 +1,142 @@
import { describe, it, expect } from 'vitest';
import {
buildMailboxTree,
flattenVisible,
mailboxesForSiblingOf,
ownMailboxes,
SHARED_ACCOUNT_NODE_PREFIX,
} from '../mailbox-tree';
import type { Mailbox } from '../../api/types';
const RIGHTS: Mailbox['myRights'] = {
mayReadItems: true,
mayAddItems: true,
mayRemoveItems: true,
maySetSeen: true,
maySetKeywords: true,
mayCreateChild: true,
mayRename: true,
mayDelete: true,
maySubmit: true,
};
function own(id: string, name: string, extra: Partial<Mailbox> = {}): Mailbox {
return {
id,
name,
totalEmails: 0,
unreadEmails: 0,
totalThreads: 0,
unreadThreads: 0,
myRights: RIGHTS,
accountId: 'acc-1',
isShared: false,
...extra,
};
}
function shared(
accountId: string,
accountName: string,
rawId: string,
name: string,
extra: Partial<Mailbox> = {},
): Mailbox {
return {
...own(`${accountId}:${rawId}`, name, extra),
originalId: rawId,
accountId,
accountName,
isShared: true,
};
}
describe('buildMailboxTree with shared accounts', () => {
it('keeps own folders at the root and groups each shared account under its own node', () => {
const tree = buildMailboxTree([
own('inbox', 'Inbox', { role: 'inbox' }),
own('sent', 'Sent', { role: 'sent' }),
shared('grp-1', 'Support', 'inbox', 'Inbox', { role: 'inbox', unreadEmails: 3 }),
shared('grp-1', 'Support', 'arch', 'Archive', { role: 'archive', unreadEmails: 1 }),
]);
expect(tree.map((n) => n.id)).toEqual([
'inbox',
'sent',
`${SHARED_ACCOUNT_NODE_PREFIX}grp-1`,
]);
const accountNode = tree[2];
expect(accountNode.isAccountNode).toBe(true);
expect(accountNode.name).toBe('Support');
// The header rolls up its account's unread so a collapsed section still
// signals waiting mail.
expect(accountNode.unreadEmails).toBe(4);
expect(accountNode.children.map((n) => n.id)).toEqual(['grp-1:inbox', 'grp-1:arch']);
expect(accountNode.children.every((n) => n.depth === 1)).toBe(true);
});
it('nests a shared account\'s subfolders under their own parent, not the user\'s', () => {
const tree = buildMailboxTree([
own('inbox', 'Inbox', { role: 'inbox' }),
shared('grp-1', 'Support', 'inbox', 'Inbox', { role: 'inbox' }),
shared('grp-1', 'Support', 'sub', 'Escalations', { parentId: 'grp-1:inbox' }),
]);
const accountNode = tree[1];
expect(accountNode.children).toHaveLength(1);
expect(accountNode.children[0].children.map((n) => n.name)).toEqual(['Escalations']);
expect(accountNode.children[0].children[0].depth).toBe(2);
});
it('gives each shared account its own node', () => {
const tree = buildMailboxTree([
shared('grp-2', 'Sales', 'inbox', 'Inbox', { role: 'inbox' }),
shared('grp-1', 'Support', 'inbox', 'Inbox', { role: 'inbox' }),
]);
expect(tree.map((n) => n.name)).toEqual(['Sales', 'Support']);
});
it('hides a collapsed shared account\'s folders', () => {
const tree = buildMailboxTree([
own('inbox', 'Inbox', { role: 'inbox' }),
shared('grp-1', 'Support', 'inbox', 'Inbox', { role: 'inbox' }),
]);
const collapsed = flattenVisible(tree, new Set());
expect(collapsed.map((n) => n.id)).toEqual(['inbox', `${SHARED_ACCOUNT_NODE_PREFIX}grp-1`]);
const expanded = flattenVisible(tree, new Set([`${SHARED_ACCOUNT_NODE_PREFIX}grp-1`]));
expect(expanded.map((n) => n.id)).toEqual([
'inbox',
`${SHARED_ACCOUNT_NODE_PREFIX}grp-1`,
'grp-1:inbox',
]);
});
});
describe('account scoping helpers', () => {
const all = [
own('inbox', 'Inbox', { role: 'inbox' }),
own('trash', 'Trash', { role: 'trash' }),
shared('grp-1', 'Support', 'inbox', 'Inbox', { role: 'inbox' }),
shared('grp-1', 'Support', 'trash', 'Trash', { role: 'trash' }),
shared('grp-2', 'Sales', 'inbox', 'Inbox', { role: 'inbox' }),
];
it('ownMailboxes drops every shared folder', () => {
expect(ownMailboxes(all).map((m) => m.id)).toEqual(['inbox', 'trash']);
});
it('scopes to the owning shared account when the current folder is shared', () => {
expect(mailboxesForSiblingOf(all, 'grp-1:inbox').map((m) => m.id))
.toEqual(['grp-1:inbox', 'grp-1:trash']);
});
it('scopes to the user\'s own folders for an own or unknown folder', () => {
expect(mailboxesForSiblingOf(all, 'inbox').map((m) => m.id)).toEqual(['inbox', 'trash']);
expect(mailboxesForSiblingOf(all, 'gone').map((m) => m.id)).toEqual(['inbox', 'trash']);
expect(mailboxesForSiblingOf(all, null).map((m) => m.id)).toEqual(['inbox', 'trash']);
});
});
src/lib/email-export.ts
+5 -3
View File
@@ -170,8 +170,8 @@ export async function downloadAttachment(
});
}
export async function fetchRawEmail(blobId: string): Promise<string> {
const url = getDownloadUrl(blobId, 'email.eml', RFC822);
export async function fetchRawEmail(blobId: string, accountId?: string): Promise<string> {
const url = getDownloadUrl(blobId, 'email.eml', RFC822, accountId);
const r = await secureFetch(url, { headers: { Authorization: authHeader() } });
if (!r.ok) throw new Error(`Download failed: ${r.status}`);
return r.text();
@@ -186,12 +186,14 @@ export async function shareEmailEml(
blobId: string,
email?: Email | null,
subjectFallback?: string,
// Owning account when the message lives in a shared/group mailbox.
accountId?: string,
): Promise<void> {
const filename = email
? emailExportFilename(email, emailFileOptions())
: safeFilename(subjectFallback);
const dest = new File(Paths.cache, filename);
const url = getDownloadUrl(blobId, dest.name, RFC822);
const url = getDownloadUrl(blobId, dest.name, RFC822, accountId);
const downloaded = await downloadInto(url, dest, Paths.cache);
if (!(await Sharing.isAvailableAsync())) {
throw new Error('Sharing is not available on this device');
src/lib/mailbox-tree.ts
+104 -8
View File
@@ -3,6 +3,33 @@ import type { Mailbox } from '../api/types';
export interface MailboxNode extends Mailbox {
children: MailboxNode[];
depth: number;
/**
* True for the virtual node that wraps a shared/group account's folders.
* It has no server-side mailbox behind it — it can be expanded but never
* selected or used as a move target.
*/
isAccountNode?: boolean;
}
// Id prefix for the virtual per-shared-account node. Matches the webmail's
// `shared-account-<accountId>` convention in [lib/utils.ts].
export const SHARED_ACCOUNT_NODE_PREFIX = 'shared-account-';
/** The user's own folders — everything not owned by a shared/group account. */
export function ownMailboxes(mailboxes: Mailbox[]): Mailbox[] {
return mailboxes.filter((m) => !m.isShared);
}
/**
* Folders belonging to the same account as `mailboxId`. Role lookups (trash,
* archive, junk…) must run inside one account: moving a message out of a
* shared folder into the user's own Trash isn't a thing JMAP can express.
* Falls back to the user's own folders when the id isn't known.
*/
export function mailboxesForSiblingOf(mailboxes: Mailbox[], mailboxId: string | null): Mailbox[] {
const current = mailboxId ? mailboxes.find((m) => m.id === mailboxId) : undefined;
if (!current?.isShared) return ownMailboxes(mailboxes);
return mailboxes.filter((m) => m.isShared && m.accountId === current.accountId);
}
// Matches `ROLE_PRIORITY` from [lib/utils.ts] in the webmail.
@@ -53,7 +80,16 @@ function sortNodes(nodes: MailboxNode[]): void {
for (const node of nodes) sortNodes(node.children);
}
export function buildMailboxTree(mailboxes: Mailbox[]): MailboxNode[] {
function recalcDepths(nodes: MailboxNode[], base: number): void {
for (const n of nodes) {
n.depth = base;
if (n.children.length > 0) recalcDepths(n.children, base + 1);
}
}
// Build the root nodes for one account's folders (parent links only resolve
// within an account — a shared folder can't nest under an own folder).
function buildRoots(mailboxes: Mailbox[]): MailboxNode[] {
const deduped = deduplicate(mailboxes);
const map = new Map<string, MailboxNode>();
const roots: MailboxNode[] = [];
@@ -69,16 +105,76 @@ export function buildMailboxTree(mailboxes: Mailbox[]): MailboxNode[] {
roots.push(node);
}
}
return roots;
}
const recalcDepths = (nodes: MailboxNode[], base: number) => {
for (const n of nodes) {
n.depth = base;
if (n.children.length > 0) recalcDepths(n.children, base + 1);
}
};
const ACCOUNT_NODE_RIGHTS: Mailbox['myRights'] = {
mayReadItems: true,
mayAddItems: false,
mayRemoveItems: false,
maySetSeen: false,
maySetKeywords: false,
mayCreateChild: false,
mayRename: false,
mayDelete: false,
maySubmit: false,
};
/**
* Own folders first, then one collapsible node per shared/group account
* holding that account's folders — the same shape the webmail sidebar uses
* (GitHub #151), so a Stalwart group mailbox shows up as its own section
* rather than being mixed into the user's folder list.
*/
export function buildMailboxTree(mailboxes: Mailbox[]): MailboxNode[] {
const own = mailboxes.filter((m) => !m.isShared);
const shared = mailboxes.filter((m) => m.isShared);
const roots = buildRoots(own);
recalcDepths(roots, 0);
sortNodes(roots);
return roots;
if (shared.length === 0) return roots;
const byAccount = new Map<string, Mailbox[]>();
for (const m of shared) {
const accountId = m.accountId ?? 'unknown';
const list = byAccount.get(accountId);
if (list) list.push(m);
else byAccount.set(accountId, [m]);
}
const accountNodes: MailboxNode[] = [];
for (const [accountId, accountMailboxes] of byAccount) {
const accountRoots = buildRoots(accountMailboxes);
// Children sit at depth 1 so the account node reads as their header.
recalcDepths(accountRoots, 1);
sortNodes(accountRoots);
const accountName = accountMailboxes[0]?.accountName || accountId;
accountNodes.push({
id: `${SHARED_ACCOUNT_NODE_PREFIX}${accountId}`,
name: accountName,
sortOrder: 1000,
totalEmails: 0,
// Roll the account's unread up to the header so a collapsed section
// still shows there's something waiting.
unreadEmails: accountMailboxes.reduce((sum, m) => sum + (m.unreadEmails ?? 0), 0),
totalThreads: 0,
unreadThreads: 0,
myRights: ACCOUNT_NODE_RIGHTS,
isSubscribed: true,
accountId,
accountName,
isShared: true,
isAccountNode: true,
children: accountRoots,
depth: 0,
});
}
accountNodes.sort((a, b) => a.name.localeCompare(b.name));
return [...roots, ...accountNodes];
}
// Flatten the tree in traversal order, skipping children of collapsed nodes.
src/navigation/types.ts
+1 -1
View File
@@ -3,7 +3,7 @@ import type { EmailAddress } from '../api/types';
export type RootStackParamList = {
MainTabs: undefined;
EmailThread: { emailId: string; threadId: string; subject?: string; jmapAccountId?: string };
EmailSource: { emailId: string; blobId: string; subject?: string };
EmailSource: { emailId: string; blobId: string; subject?: string; jmapAccountId?: string };
Compose:
| {
mode?: 'reply' | 'replyAll' | 'forward';
src/screens/ComposeScreen.tsx
+4 -1
View File
@@ -23,6 +23,7 @@ import RichTextEditor, {
type RichTextSelectionState,
} from '../components/RichTextEditor';
import { useEmailStore } from '../stores/email-store';
import { ownMailboxes } from '../lib/mailbox-tree';
import { useContactsStore } from '../stores/contacts-store';
import { useLocaleStore } from '../stores/locale-store';
import { useSettingsStore } from '../stores/settings-store';
@@ -263,8 +264,10 @@ export default function ComposeScreen({ route, navigation }: Props) {
const mode = route.params?.mode ?? 'compose';
const prefillTo = route.params?.prefillTo;
const mailboxes = useEmailStore((s) => s.mailboxes);
// Always the user's own Sent — composing on behalf of a shared account
// isn't supported, so a group account's Sent must never be picked up here.
const sentMailbox = React.useMemo(
() => mailboxes.find((m) => m.role === 'sent'),
() => ownMailboxes(mailboxes).find((m) => m.role === 'sent'),
[mailboxes],
);
src/screens/EmailListScreen.tsx
+30 -13
View File
@@ -24,7 +24,9 @@ import { useSettingsStore, type SwipeAction } from '../stores/settings-store';
import { useKeywordsStore } from '../stores/keywords-store';
import { useLocaleStore } from '../stores/locale-store';
import { formatListDate } from '../lib/date-format';
import { findTrashMailbox, findArchiveMailbox, findJunkMailbox } from '../lib/mailbox-tree';
import {
findTrashMailbox, findArchiveMailbox, findJunkMailbox, mailboxesForSiblingOf, ownMailboxes,
} from '../lib/mailbox-tree';
import type { Email } from '../api/types';
function getSenderName(email: Email): string {
return email.from?.[0]?.name || email.from?.[0]?.email || 'Unknown';
@@ -243,24 +245,31 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
return counts;
}, [emails, disableThreading]);
// Role folders must come from the account the open folder belongs to: a
// shared (group account) message can only be filed into that account's
// Archive/Trash/Junk, never the user's own.
const scopedMailboxes = React.useMemo(
() => mailboxesForSiblingOf(mailboxes, currentMailboxId),
[mailboxes, currentMailboxId],
);
const archiveMailboxId = React.useMemo(
() => findArchiveMailbox(mailboxes)?.id ?? null,
[mailboxes],
() => findArchiveMailbox(scopedMailboxes)?.id ?? null,
[scopedMailboxes],
);
const trashMailboxId = React.useMemo(
() => findTrashMailbox(mailboxes)?.id ?? null,
[mailboxes],
() => findTrashMailbox(scopedMailboxes)?.id ?? null,
[scopedMailboxes],
);
const junkMailboxId = React.useMemo(
() => findJunkMailbox(mailboxes)?.id ?? null,
[mailboxes],
() => findJunkMailbox(scopedMailboxes)?.id ?? null,
[scopedMailboxes],
);
// Import .eml / .zip files into the current mailbox (falls back to Inbox).
const [importing, setImporting] = React.useState(false);
const handleImport = React.useCallback(async () => {
const targetMailboxId =
currentMailboxId ?? mailboxes.find((m) => m.role === 'inbox')?.id ?? null;
currentMailboxId ?? ownMailboxes(mailboxes).find((m) => m.role === 'inbox')?.id ?? null;
if (!targetMailboxId || importing) return;
let result: DocumentPicker.DocumentPickerResult;
try {
@@ -460,7 +469,7 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
};
const handleBulkDelete = async () => {
const trash = findTrashMailbox(mailboxes);
const trash = findTrashMailbox(scopedMailboxes);
if (!trash || !currentMailboxId) {
clearSelection();
return;
@@ -548,7 +557,9 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
React.useEffect(() => {
if (mailboxes.length > 0 && !currentMailboxId) {
const inbox = mailboxes.find((m) => m.role === 'inbox') || mailboxes[0];
const own = ownMailboxes(mailboxes);
const inbox = own.find((m) => m.role === 'inbox') || own[0];
if (!inbox) return;
void selectMailbox(inbox.id);
}
}, [mailboxes, currentMailboxId, selectMailbox]);
@@ -620,7 +631,13 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
<Pressable onPress={() => setDrawerOpen(true)} style={styles.headerButton}>
<Menu size={20} color={c.textMuted} />
</Pressable>
<Text style={styles.headerTitle} numberOfLines={1}>{currentMailbox?.name ?? 'Inbox'}</Text>
<Text style={styles.headerTitle} numberOfLines={1}>
{currentMailbox?.isShared && currentMailbox.accountName
// Name the owning group account — a bare "Inbox" would look like
// the user's own.
? `${currentMailbox.accountName} · ${currentMailbox.name}`
: currentMailbox?.name ?? 'Inbox'}
</Text>
<View style={{ flex: 1 }} />
<Pressable
onPress={() => { void handleImport(); }}
@@ -1013,7 +1030,7 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
<MoveSheet
visible={pendingMoveId !== null}
onClose={() => setPendingMoveId(null)}
mailboxes={mailboxes}
mailboxes={scopedMailboxes}
currentMailboxId={currentMailboxId}
onPick={(toId) => {
const id = pendingMoveId;
@@ -1027,7 +1044,7 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
<MoveSheet
visible={batchMoveOpen}
onClose={() => setBatchMoveOpen(false)}
mailboxes={mailboxes}
mailboxes={scopedMailboxes}
currentMailboxId={currentMailboxId}
onPick={handleBatchMovePick}
/>
src/screens/EmailSourceScreen.tsx
+6 -4
View File
@@ -15,7 +15,9 @@ type Props = NativeStackScreenProps<RootStackParamList, 'EmailSource'>;
export default function EmailSourceScreen({ route, navigation }: Props) {
const c = useColors();
const styles = React.useMemo(() => makeStyles(c), [c]);
const { blobId, subject } = route.params;
// Blobs are account-scoped, so a message from a shared/group mailbox has
// to be fetched against its owning account.
const { blobId, subject, jmapAccountId } = route.params;
const [raw, setRaw] = React.useState<string | null>(null);
const [error, setError] = React.useState<string | null>(null);
@@ -23,18 +25,18 @@ export default function EmailSourceScreen({ route, navigation }: Props) {
let cancelled = false;
void (async () => {
try {
const text = await fetchRawEmail(blobId);
const text = await fetchRawEmail(blobId, jmapAccountId);
if (!cancelled) setRaw(text);
} catch (e) {
if (!cancelled) setError(e instanceof Error ? e.message : 'Failed to load email source');
}
})();
return () => { cancelled = true; };
}, [blobId]);
}, [blobId, jmapAccountId]);
const onShare = async () => {
try {
await shareEmailEml(blobId, undefined, subject);
await shareEmailEml(blobId, undefined, subject, jmapAccountId);
} catch (e) {
Alert.alert('Share failed', e instanceof Error ? e.message : String(e));
}
src/screens/EmailThreadScreen.tsx
+51 -26
View File
@@ -30,7 +30,7 @@ import { shareEmailEml, shareAttachment, downloadAttachment } from '../lib/email
import { useKeywordsStore, keywordToken, type KeywordDef } from '../stores/keywords-store';
import { useSheetDrag } from '../lib/use-sheet-drag';
import { useLocaleStore } from '../stores/locale-store';
import { findTrashMailbox } from '../lib/mailbox-tree';
import { findTrashMailbox, mailboxesForSiblingOf } from '../lib/mailbox-tree';
import type { Email, Mailbox } from '../api/types';
import type { RootStackParamList } from '../navigation/types';
@@ -84,6 +84,17 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
const currentMailboxId = useEmailStore((s) => s.currentMailboxId);
const emails = useEmailStore((s) => s.emails);
// The JMAP account the open message belongs to: the route param when the
// unified inbox opened a group message, otherwise the account behind the
// folder it was opened from. Undefined means the user's own mail.
const ownerAccountId = React.useMemo(() => {
if (jmapAccountId) return jmapAccountId;
const current = currentMailboxId
? mailboxes.find((m) => m.id === currentMailboxId)
: undefined;
return current?.isShared ? current.accountId : undefined;
}, [jmapAccountId, mailboxes, currentMailboxId]);
const currentIndex = emails.findIndex((e) => e.id === activeEmailId);
const prevEmail = currentIndex > 0 ? emails[currentIndex - 1] : null;
const nextEmail = currentIndex >= 0 && currentIndex < emails.length - 1 ? emails[currentIndex + 1] : null;
@@ -128,13 +139,13 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
const ensureDetail = React.useCallback((id: string): Promise<Email | null> => {
const pending = inFlight.get(id);
if (pending) return pending;
const p = getEmailDetail(id, jmapAccountId)
const p = getEmailDetail(id, ownerAccountId)
.then((fetched) => { detailCache.set(id, fetched); bumpCache(); return fetched; })
.catch(() => detailCache.get(id) ?? null)
.finally(() => { inFlight.delete(id); });
inFlight.set(id, p);
return p;
}, [getEmailDetail, jmapAccountId, detailCache, bumpCache, inFlight]);
}, [getEmailDetail, ownerAccountId, detailCache, bumpCache, inFlight]);
// Slide to a page by index and reflect it in the toolbar immediately; a swipe
// that settles on the same page confirms the same id via onMomentumEnd.
@@ -190,9 +201,9 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
setDownloadingBlobId(blobId);
try {
if (mailAttachmentAction === 'download') {
await downloadAttachment(blobId, name, type, target);
await downloadAttachment(blobId, name, type, target, ownerAccountId);
} else {
await shareAttachment(blobId, name, type, target);
await shareAttachment(blobId, name, type, target, ownerAccountId);
}
} catch (e) {
Alert.alert('Download failed', e instanceof Error ? e.message : String(e));
@@ -200,7 +211,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
setDownloadingBlobId(null);
}
},
[downloadingBlobId, mailAttachmentAction],
[downloadingBlobId, mailAttachmentAction, ownerAccountId],
);
const keywordDefs = useKeywordsStore((s) => s.keywords);
const hydrateKeywords = useKeywordsStore((s) => s.hydrate);
@@ -226,10 +237,10 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
if (!fetched.keywords?.$seen) {
if (markAsReadDelay > 0) {
readTimer = setTimeout(() => {
if (!cancelled) void markRead(activeEmailId, jmapAccountId);
if (!cancelled) void markRead(activeEmailId, ownerAccountId);
}, markAsReadDelay);
} else {
void markRead(activeEmailId, jmapAccountId);
void markRead(activeEmailId, ownerAccountId);
}
}
})();
@@ -237,24 +248,33 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
cancelled = true;
if (readTimer) clearTimeout(readTimer);
};
}, [activeEmailId, ensureDetail, markRead, markAsReadDelay, jmapAccountId, detailCache]);
}, [activeEmailId, ensureDetail, markRead, markAsReadDelay, ownerAccountId, detailCache]);
const starred = !!email?.keywords?.$flagged;
const unread = !!email && !email.keywords?.$seen;
// Move/archive/spam targets have to live in the same account as the folder
// the message was opened from — a shared (group account) message can't be
// filed into the user's own folders.
const scopedMailboxes = React.useMemo(
() => mailboxesForSiblingOf(mailboxes, currentMailboxId),
[mailboxes, currentMailboxId],
);
const archiveMailbox = React.useMemo(
() => mailboxes.find((m) => m.role === 'archive'),
[mailboxes],
() => scopedMailboxes.find((m) => m.role === 'archive'),
[scopedMailboxes],
);
const junkMailbox = React.useMemo(
() => mailboxes.find((m) => m.role === 'junk' || m.role === 'spam'),
[mailboxes],
() => scopedMailboxes.find((m) => m.role === 'junk' || m.role === 'spam'),
[scopedMailboxes],
);
const inboxMailbox = React.useMemo(
() => mailboxes.find((m) => m.role === 'inbox'),
[mailboxes],
() => scopedMailboxes.find((m) => m.role === 'inbox'),
[scopedMailboxes],
);
const isInJunk = !!(junkMailbox && email?.mailboxIds?.[junkMailbox.id]);
// `mailboxIds` comes back from the server unprefixed, so compare on the
// folder's raw id rather than the sidebar key.
const isInJunk = !!(junkMailbox && email?.mailboxIds?.[junkMailbox.originalId ?? junkMailbox.id]);
// Optimistically write a message's keywords into the cache (the single source
// of truth for every pane) and bump the version so the panes re-render.
@@ -271,7 +291,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
if (next[token]) delete next[token];
else next[token] = true;
updateLocalKeywords(email.id, next);
void setEmailKeywords(email.id, next);
void setEmailKeywords(email.id, next, ownerAccountId);
};
// Toggle the star on a specific message — used both by the toolbar (current
@@ -282,27 +302,27 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
else next.$flagged = true;
const prev = detailCache.get(target.id);
if (prev) { detailCache.set(target.id, { ...prev, keywords: next }); bumpCache(); }
void setEmailKeywords(target.id, next);
}, [detailCache, bumpCache]);
void setEmailKeywords(target.id, next, ownerAccountId);
}, [detailCache, bumpCache, ownerAccountId]);
const onToggleStar = () => { if (email) toggleStarFor(email); };
const onToggleUnread = () => {
if (!email) return;
if (unread) {
void markRead(email.id);
void markRead(email.id, ownerAccountId);
updateLocalKeywords(email.id, { ...email.keywords, $seen: true });
} else {
const next = { ...email.keywords };
delete next.$seen;
updateLocalKeywords(email.id, next);
void setEmailKeywords(email.id, next);
void setEmailKeywords(email.id, next, ownerAccountId);
}
};
const onDelete = () => {
if (!email || !currentMailboxId) return;
const trash = findTrashMailbox(mailboxes);
const trash = findTrashMailbox(scopedMailboxes);
if (!trash) {
Alert.alert(
t('email_list.error', 'Error'),
@@ -325,7 +345,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
if (!email || !currentMailboxId) return;
setMoreMenuOpen(false);
if (isInJunk) {
const target = inboxMailbox ?? mailboxes.find((m) => m.id !== currentMailboxId);
const target = inboxMailbox ?? scopedMailboxes.find((m) => m.id !== currentMailboxId);
if (!target) return;
void moveToMailbox(email.id, currentMailboxId, target.id);
} else {
@@ -534,6 +554,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
<EmailPane
id={item.id}
email={detailCache.get(item.id) ?? null}
jmapAccountId={ownerAccountId}
ensureDetail={ensureDetail}
c={c}
styles={styles}
@@ -604,6 +625,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
emailId: email.id,
blobId: email.blobId,
subject: email.subject,
jmapAccountId: ownerAccountId,
});
}
}}
@@ -611,7 +633,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
setMoreMenuOpen(false);
if (!email?.blobId) return;
try {
await shareEmailEml(email.blobId, email);
await shareEmailEml(email.blobId, email, undefined, ownerAccountId);
} catch (e) {
Alert.alert('Export failed', e instanceof Error ? e.message : String(e));
}
@@ -621,7 +643,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
<MoveSheet
visible={moveMenuOpen}
onClose={() => setMoveMenuOpen(false)}
mailboxes={mailboxes}
mailboxes={scopedMailboxes}
currentMailboxId={currentMailboxId}
onPick={onMoveToMailbox}
/>
@@ -640,6 +662,8 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
interface EmailPaneProps {
id: string;
email: Email | null;
/** Owning account when the message lives in a shared/group mailbox. */
jmapAccountId?: string;
ensureDetail: (id: string) => Promise<Email | null>;
c: ThemePalette;
styles: ReturnType<typeof makeStyles>;
@@ -659,7 +683,7 @@ interface EmailPaneProps {
// scroll position and "show all attachments" toggle, and renders directly from
// the email passed to it — neighbours show real content, not a placeholder.
function EmailPane({
id, email, ensureDetail, c, styles, bottomBarHeight, attachmentPosition,
id, email, jmapAccountId, ensureDetail, c, styles, bottomBarHeight, attachmentPosition,
hideInlineImageAttachments, downloadingBlobId, onToggleStar, onPressAttachment, onSwipe,
onZoomChange,
}: EmailPaneProps) {
@@ -806,6 +830,7 @@ function EmailPane({
<EmailBodyView
email={email}
senderEmail={from?.email}
jmapAccountId={jmapAccountId}
onSwipe={onSwipe}
onZoomChange={(z) => { setPinching(z.pinching); onZoomChange(z); }}
/>
src/stores/__tests__/email-store.test.ts
+101 -8
View File
@@ -5,6 +5,7 @@ vi.mock('../../api/email', () => ({
// New helpers used by the incremental-sync path. Default behavior: behave
// like a first-ever load — no prior state, full re-query expected.
getMailboxesWithState: vi.fn(async () => ({ list: [], state: 'mb-state-0' })),
getSharedMailboxes: vi.fn(async () => []),
getMailboxesByIds: vi.fn(async () => ({ list: [], state: 'mb-state-0' })),
getMailboxChanges: vi.fn(async () => null),
queryEmails: vi.fn(),
@@ -24,6 +25,8 @@ vi.mock('../../api/email', () => ({
deleteEmail: vi.fn(),
deleteEmails: vi.fn(),
searchEmails: vi.fn(),
unprefixMailboxId: (id: string, accountId?: string) =>
(accountId && id.startsWith(`${accountId}:`) ? id.slice(accountId.length + 1) : id),
}));
// The mutations now route through the offline outbox. In tests we want the
@@ -31,11 +34,11 @@ vi.mock('../../api/email', () => ({
// op's primitive) immediately so the existing api-call assertions still hold,
// without pulling in network-store / NetInfo.
vi.mock('../outbox-store', async () => {
const api = await import('../../api/email') as Record<string, (...args: unknown[]) => Promise<unknown>>;
const runOp = async (op: { kind: string; emailId: string; keywords?: unknown; mailboxIds?: unknown }) => {
if (op.kind === 'keywords') return api.setEmailKeywords(op.emailId, op.keywords);
if (op.kind === 'mailboxes') return api.setEmailMailboxes(op.emailId, op.mailboxIds);
if (op.kind === 'destroy') return api.destroyEmails([op.emailId]);
const api = await import('../../api/email') as unknown as Record<string, (...args: unknown[]) => Promise<unknown>>;
const runOp = async (op: { kind: string; emailId: string; accountId?: string; keywords?: unknown; mailboxIds?: unknown }) => {
if (op.kind === 'keywords') return api.setEmailKeywords(op.emailId, op.keywords, op.accountId);
if (op.kind === 'mailboxes') return api.setEmailMailboxes(op.emailId, op.mailboxIds, op.accountId);
if (op.kind === 'destroy') return api.destroyEmails([op.emailId], op.accountId);
};
const applyOrQueueBatch = async (ops: any[], onlineRun?: () => Promise<void>) => {
if (onlineRun) await onlineRun();
@@ -100,6 +103,8 @@ vi.mock('../../api/jmap-client', () => ({
currentSession: { apiUrl: 'https://mail.example.com/jmap/' },
// refreshEmails / loadMoreEmails chunk by this value when fetching ids.
getMaxObjectsInGet: () => 500,
getMaxCallsInRequest: () => 16,
getSharedMailAccounts: () => [{ id: 'grp-1', name: 'Support' }],
},
}));
@@ -110,6 +115,7 @@ import * as emailApi from '../../api/email';
import { useEmailStore } from '../email-store';
const mockGetMailboxesWithState = emailApi.getMailboxesWithState as ReturnType<typeof vi.fn>;
const mockGetSharedMailboxes = emailApi.getSharedMailboxes as ReturnType<typeof vi.fn>;
const mockQueryEmails = emailApi.queryEmails as ReturnType<typeof vi.fn>;
const mockGetEmailQueryChanges = emailApi.getEmailQueryChanges as ReturnType<typeof vi.fn>;
const mockGetEmails = emailApi.getEmails as ReturnType<typeof vi.fn>;
@@ -224,7 +230,7 @@ describe('email-store', () => {
await useEmailStore.getState().markRead('e1');
expect(mockSetKeywords).toHaveBeenCalledWith('e1', { $seen: true });
expect(mockSetKeywords).toHaveBeenCalledWith('e1', { $seen: true }, undefined);
expect(useEmailStore.getState().emails[0].keywords.$seen).toBe(true);
});
});
@@ -238,7 +244,7 @@ describe('email-store', () => {
await useEmailStore.getState().markUnread('e1');
expect(mockSetKeywords).toHaveBeenCalledWith('e1', { $flagged: true });
expect(mockSetKeywords).toHaveBeenCalledWith('e1', { $flagged: true }, undefined);
expect(useEmailStore.getState().emails[0].keywords.$seen).toBeUndefined();
});
});
@@ -276,7 +282,7 @@ describe('email-store', () => {
await useEmailStore.getState().moveToMailbox('e1', 'inbox', 'archive');
expect(mockMoveEmail).toHaveBeenCalledWith('e1', 'inbox', 'archive');
expect(mockMoveEmail).toHaveBeenCalledWith('e1', 'inbox', 'archive', undefined);
expect(useEmailStore.getState().emails).toHaveLength(1);
expect(useEmailStore.getState().emails[0].id).toBe('e2');
});
@@ -467,4 +473,91 @@ describe('email-store', () => {
expect(result).toEqual(fullEmail);
});
});
// ── Shared (Stalwart group account) mailboxes ────────────────────────────
describe('shared mailboxes', () => {
const RIGHTS = {
mayReadItems: true, mayAddItems: true, mayRemoveItems: true,
maySetSeen: true, maySetKeywords: true, mayCreateChild: true,
mayRename: true, mayDelete: true, maySubmit: true,
};
const ownInbox = {
id: 'mb-1', name: 'Inbox', role: 'inbox', totalEmails: 0, unreadEmails: 0,
totalThreads: 0, unreadThreads: 0, myRights: RIGHTS,
accountId: 'acc-1', isShared: false,
} as any;
const sharedInbox = {
id: 'grp-1:s-inbox', originalId: 's-inbox', name: 'Inbox', role: 'inbox',
totalEmails: 0, unreadEmails: 0, totalThreads: 0, unreadThreads: 0,
myRights: RIGHTS, accountId: 'grp-1', accountName: 'Support', isShared: true,
} as any;
const sharedTrash = {
...sharedInbox, id: 'grp-1:s-trash', originalId: 's-trash', name: 'Trash', role: 'trash',
} as any;
it('merges shared folders in alongside the own ones', async () => {
mockGetMailboxesWithState.mockResolvedValue({ list: [ownInbox], state: 'mb-1' });
mockGetSharedMailboxes.mockResolvedValue([sharedInbox]);
await useEmailStore.getState().fetchMailboxes();
expect(useEmailStore.getState().mailboxes).toEqual([ownInbox, sharedInbox]);
});
it('keeps the own folders when a shared account cannot be reached', async () => {
mockGetMailboxesWithState.mockResolvedValue({ list: [ownInbox], state: 'mb-1' });
mockGetSharedMailboxes.mockRejectedValue(new Error('Session expired'));
await useEmailStore.getState().fetchMailboxes();
const state = useEmailStore.getState();
expect(state.mailboxes).toEqual([ownInbox]);
expect(state.error).toBeNull();
});
it('queries a shared folder against its owning account by raw id', async () => {
useEmailStore.setState({ mailboxes: [ownInbox, sharedInbox] });
mockQueryEmails.mockResolvedValue({ ids: ['e1'], total: 1, queryState: 'q-1' });
mockGetEmailsWithState.mockResolvedValue({
list: [{ id: 'e1', subject: 'Hi' }], state: 'em-1',
});
await useEmailStore.getState().selectMailbox('grp-1:s-inbox');
expect(mockQueryEmails).toHaveBeenCalledWith('s-inbox', expect.objectContaining({
accountId: 'grp-1',
filter: { inMailbox: 's-inbox' },
}));
expect(mockGetEmailsWithState).toHaveBeenCalledWith(['e1'], 'grp-1');
// Email state tokens are per-account, so the shared account gets its own.
expect(useEmailStore.getState().emailStates).toEqual({ 'grp-1': 'em-1' });
});
it('deletes from a shared folder against the owning account', async () => {
useEmailStore.setState({
mailboxes: [ownInbox, sharedInbox, sharedTrash],
currentMailboxId: 'grp-1:s-inbox',
emails: [{ id: 'e1', keywords: {}, mailboxIds: { 's-inbox': true } } as any],
});
await useEmailStore.getState().deleteEmail('e1', 'grp-1:s-trash', 'grp-1:s-inbox');
expect(mockDeleteEmail).toHaveBeenCalledWith('e1', 's-trash', 's-inbox', 'grp-1');
expect(useEmailStore.getState().emails).toHaveLength(0);
});
it('refuses to move a message between accounts', async () => {
useEmailStore.setState({
mailboxes: [ownInbox, sharedInbox],
currentMailboxId: 'grp-1:s-inbox',
emails: [{ id: 'e1', keywords: {}, mailboxIds: { 's-inbox': true } } as any],
});
await useEmailStore.getState().moveToMailbox('e1', 'grp-1:s-inbox', 'mb-1');
expect(mockMoveEmail).not.toHaveBeenCalled();
const state = useEmailStore.getState();
expect(state.error).toMatch(/same account/);
expect(state.emails).toHaveLength(1);
});
});
});
src/stores/__tests__/outbox-store.test.ts
+4 -4
View File
@@ -79,7 +79,7 @@ describe('applyOrQueue', () => {
it('runs immediately when online with an empty queue', async () => {
const result = await applyOrQueue({ kind: 'keywords', emailId: 'e1', keywords: { $seen: true } });
expect(result.queued).toBe(false);
expect(setEmailKeywords).toHaveBeenCalledWith('e1', { $seen: true });
expect(setEmailKeywords).toHaveBeenCalledWith('e1', { $seen: true }, undefined);
expect(useOutboxStore.getState().entries).toHaveLength(0);
});
@@ -137,9 +137,9 @@ describe('flush', () => {
useNetworkStore.setState({ online: true });
await useOutboxStore.getState().flush();
expect(setEmailKeywords).toHaveBeenCalledWith('e1', { $seen: true });
expect(setEmailMailboxes).toHaveBeenCalledWith('e2', { trash: true });
expect(destroyEmails).toHaveBeenCalledWith(['e3']);
expect(setEmailKeywords).toHaveBeenCalledWith('e1', { $seen: true }, undefined);
expect(setEmailMailboxes).toHaveBeenCalledWith('e2', { trash: true }, undefined);
expect(destroyEmails).toHaveBeenCalledWith(['e3'], undefined);
expect(useOutboxStore.getState().entries).toHaveLength(0);
});
src/stores/email-store.ts
+367 -120
View File
@@ -6,6 +6,7 @@ import { jmapClient } from '../api/jmap-client';
import {
getMailboxes as fetchMailboxes,
getMailboxesWithState,
getSharedMailboxes,
getMailboxesByIds,
getMailboxChanges,
queryEmails,
@@ -24,7 +25,9 @@ import {
deleteEmails as apiDeleteEmails,
restoreEmailMailboxes,
searchEmails as apiSearchEmails,
unprefixMailboxId,
} from '../api/email';
import { mailboxesForSiblingOf } from '../lib/mailbox-tree';
import { toWildcardQuery } from '../lib/search-utils';
import { generateAccountId } from '../lib/account-utils';
import { useSettingsStore } from './settings-store';
@@ -54,6 +57,69 @@ function mailboxesAfterMove(
return next;
}
// Where a folder actually lives. The user's own folders keep their raw JMAP id
// and get no account override, so every existing call path stays exactly as it
// was; a shared (Stalwart group account) folder resolves to its owning account
// plus the unprefixed id the server knows it by.
interface MailboxRef {
/** JMAP account override — undefined for the user's own folders. */
accountId?: string;
/** Id to send to the server, with any `<accountId>:` prefix stripped. */
id: string;
}
function refFor(mailboxes: Mailbox[], mailboxId: string): MailboxRef {
const mailbox = mailboxes.find((m) => m.id === mailboxId);
if (!mailbox?.isShared) return { id: mailboxId };
return { accountId: mailbox.accountId, id: mailbox.originalId ?? mailboxId };
}
function rawMailboxId(mailboxes: Mailbox[], mailboxId: string): string {
return refFor(mailboxes, mailboxId).id;
}
// The JMAP account behind the folder currently on screen. Undefined for the
// user's own folders, which keeps every own-mail call on the default path.
function currentAccountId(state: EmailState): string | undefined {
if (!state.currentMailboxId) return undefined;
return refFor(state.mailboxes, state.currentMailboxId).accountId;
}
// Strip the shared-folder id prefix off a whole list. Server-side folder
// matching (archive year/month auto-foldering) compares ids and parent links
// against what Mailbox/set returns, which is always unprefixed.
function toRawMailboxes(mailboxes: Mailbox[]): Mailbox[] {
return mailboxes.map((m) => (m.isShared
? {
...m,
id: m.originalId ?? m.id,
parentId: m.parentId ? unprefixMailboxId(m.parentId, m.accountId) : m.parentId,
}
: m));
}
// Key for `emailStates`. JMAP Email state tokens are per-account, so the
// primary account and each shared account track their own.
const PRIMARY_STATE_KEY = '@primary';
function stateKey(accountId?: string): string {
return accountId ?? PRIMARY_STATE_KEY;
}
// Record (or forget, when the server said cannotCalculateChanges) one
// account's Email state without disturbing the others'.
function withEmailState(
states: Record<string, string>,
accountId: string | undefined,
value: string | undefined,
): Record<string, string> {
const key = stateKey(accountId);
if (value === undefined) {
const { [key]: _drop, ...rest } = states;
return rest;
}
return { ...states, [key]: value };
}
// True only when the JMAP client is actually serving the email-store's active
// account. During an account switch there's a window between
// setActiveAccount() (which swaps the email-store view immediately) and
@@ -91,6 +157,8 @@ export interface UndoEntry {
label: string;
/** Time the entry was created - the snackbar uses this to drive its timer. */
createdAt: number;
/** JMAP account the messages live under; unset for the user's own mail. */
accountId?: string;
/** Each item is one email's pre-action mailboxIds, used to restore it. */
items: Array<{ email: Email; originalMailboxIds: Record<string, boolean> }>;
}
@@ -109,7 +177,9 @@ interface MailboxSnapshot {
interface AccountSnapshot {
mailboxes: Mailbox[];
mailboxState?: string; // JMAP Mailbox state (drives Mailbox/changes)
emailState?: string; // JMAP Email state (drives Email/changes)
// JMAP Email state per JMAP account (drives Email/changes). Keyed by
// `stateKey()`: the primary account plus any shared/group accounts.
emailStates: Record<string, string>;
currentMailboxId: string | null;
mailboxSnapshots: Record<string, MailboxSnapshot>;
}
@@ -118,7 +188,7 @@ export interface EmailState {
// ── Per-account persisted caches ──────────────────────────────
// accountSnapshots is the source of truth for accounts the user is *not*
// currently viewing. The active account's data lives in the top-level
// fields below (`mailboxes`, `mailboxSnapshots`, `mailboxState`, `emailState`,
// fields below (`mailboxes`, `mailboxSnapshots`, `mailboxState`, `emailStates`,
// `currentMailboxId`, `emails`, `totalEmails`, `queryState`) so consumers
// keep reading the same shape they always have.
accountSnapshots: Record<string, AccountSnapshot>;
@@ -127,7 +197,7 @@ export interface EmailState {
// ── Active view (the currently-shown account/mailbox) ─────────
mailboxes: Mailbox[];
mailboxState?: string;
emailState?: string;
emailStates: Record<string, string>;
currentMailboxId: string | null;
mailboxSnapshots: Record<string, MailboxSnapshot>;
emails: Email[];
@@ -251,7 +321,7 @@ function snapshotFromActive(state: EmailState): AccountSnapshot {
return {
mailboxes: state.mailboxes,
mailboxState: state.mailboxState,
emailState: state.emailState,
emailStates: state.emailStates,
currentMailboxId: state.currentMailboxId,
mailboxSnapshots,
};
@@ -260,7 +330,7 @@ function snapshotFromActive(state: EmailState): AccountSnapshot {
function viewFromSnapshot(snap: AccountSnapshot | null): {
mailboxes: Mailbox[];
mailboxState?: string;
emailState?: string;
emailStates: Record<string, string>;
currentMailboxId: string | null;
mailboxSnapshots: Record<string, MailboxSnapshot>;
emails: Email[];
@@ -271,7 +341,7 @@ function viewFromSnapshot(snap: AccountSnapshot | null): {
return {
mailboxes: [],
mailboxState: undefined,
emailState: undefined,
emailStates: {},
currentMailboxId: null,
mailboxSnapshots: {},
emails: [],
@@ -285,7 +355,7 @@ function viewFromSnapshot(snap: AccountSnapshot | null): {
return {
mailboxes: snap.mailboxes,
mailboxState: snap.mailboxState,
emailState: snap.emailState,
emailStates: snap.emailStates ?? {},
currentMailboxId: snap.currentMailboxId,
mailboxSnapshots: snap.mailboxSnapshots,
emails: mailboxSnap?.emails ?? [],
@@ -297,14 +367,14 @@ function viewFromSnapshot(snap: AccountSnapshot | null): {
// JMAP's maxObjectsInGet bounds how many ids we can pull in one Email/get.
// Chunk to that ceiling (with a small safety fallback) so large change sets
// don't trip 429/413 responses.
async function fetchEmailsChunked(ids: string[]): Promise<Email[]> {
async function fetchEmailsChunked(ids: string[], accountId?: string): Promise<Email[]> {
if (ids.length === 0) return [];
const cap = Math.max(1, jmapClient.getMaxObjectsInGet());
const chunk = Math.min(cap, 200);
if (ids.length <= chunk) return fetchEmails(ids);
if (ids.length <= chunk) return fetchEmails(ids, accountId);
const out: Email[] = [];
for (let i = 0; i < ids.length; i += chunk) {
const slice = await fetchEmails(ids.slice(i, i + chunk));
const slice = await fetchEmails(ids.slice(i, i + chunk), accountId);
out.push(...slice);
}
return out;
@@ -340,7 +410,7 @@ export const useEmailStore = create<EmailState>()(
mailboxes: [],
mailboxState: undefined,
emailState: undefined,
emailStates: {},
currentMailboxId: null,
mailboxSnapshots: {},
emails: [],
@@ -403,7 +473,7 @@ export const useEmailStore = create<EmailState>()(
activeAccountId: null,
mailboxes: [],
mailboxState: undefined,
emailState: undefined,
emailStates: {},
currentMailboxId: null,
mailboxSnapshots: {},
emails: [],
@@ -426,7 +496,7 @@ export const useEmailStore = create<EmailState>()(
activeAccountId: null,
mailboxes: [],
mailboxState: undefined,
emailState: undefined,
emailStates: {},
currentMailboxId: null,
mailboxSnapshots: {},
emails: [],
@@ -455,16 +525,30 @@ export const useEmailStore = create<EmailState>()(
if (!jmapClientServesActiveAccount(activeAccountId)) return;
const prevState = get().mailboxState;
// Swap in a freshly-synced set of own folders while leaving the shared
// (group account) ones alone, and vice versa — the two are fetched by
// separate calls and must not clobber each other.
const replaceOwn = (own: Mailbox[], mailboxState?: string) => {
set({
mailboxes: [...own, ...get().mailboxes.filter((m) => m.isShared)],
...(mailboxState !== undefined ? { mailboxState } : {}),
});
};
try {
let drainAgain = false;
// Incremental path: ask for just what changed since last time. Fall
// through to a full refetch when the server can't compute the diff or
// we have no previous state to compare against.
let syncedOwn = false;
if (prevState) {
const changes = await getMailboxChanges(prevState);
// Bail if the user switched accounts during the await — anything we
// set() now would land in the wrong account's bucket.
if (get().activeAccountId !== activeAccountId) return;
if (changes) {
syncedOwn = true;
// No changes at all — keep the cached list, just bump the state.
if (
changes.created.length === 0 &&
@@ -472,35 +556,50 @@ export const useEmailStore = create<EmailState>()(
changes.destroyed.length === 0
) {
set({ mailboxState: changes.newState });
return;
} else {
const toFetch = [...changes.created, ...changes.updated];
const fetched = toFetch.length > 0
? (await getMailboxesByIds(toFetch)).list
: [];
if (get().activeAccountId !== activeAccountId) return;
const destroyed = new Set(changes.destroyed);
const byId = new Map<string, Mailbox>();
for (const m of get().mailboxes) {
if (!m.isShared) byId.set(m.id, m);
}
for (const m of fetched) byId.set(m.id, m);
for (const id of destroyed) byId.delete(id);
replaceOwn(
Array.from(byId.values()),
changes.hasMoreChanges ? prevState : changes.newState,
);
// hasMoreChanges = there are still pending changes past the
// server's response cap. Run the same path again to drain.
drainAgain = changes.hasMoreChanges;
}
const toFetch = [...changes.created, ...changes.updated];
const fetched = toFetch.length > 0
? (await getMailboxesByIds(toFetch)).list
: [];
if (get().activeAccountId !== activeAccountId) return;
const destroyed = new Set(changes.destroyed);
const byId = new Map<string, Mailbox>();
for (const m of get().mailboxes) byId.set(m.id, m);
for (const m of fetched) byId.set(m.id, m);
for (const id of destroyed) byId.delete(id);
set({
mailboxes: Array.from(byId.values()),
mailboxState: changes.hasMoreChanges ? prevState : changes.newState,
});
// hasMoreChanges = there are still pending changes past the
// server's response cap. Run the same path again to drain.
if (changes.hasMoreChanges) {
void get().fetchMailboxes();
}
return;
}
// changes === null → cannotCalculateChanges. Fall through to full.
}
const { list, state } = await getMailboxesWithState();
if (get().activeAccountId !== activeAccountId) return;
set({ mailboxes: list, mailboxState: state });
if (!syncedOwn) {
const { list, state } = await getMailboxesWithState();
if (get().activeAccountId !== activeAccountId) return;
replaceOwn(list, state);
}
// Shared/group accounts have their own Mailbox state tokens, and there
// are only ever a handful of them, so they're re-read in full rather
// than diffed. Failing to reach one must not lose the own folders we
// just synced, hence the separate try.
try {
const shared = await getSharedMailboxes();
if (get().activeAccountId !== activeAccountId) return;
set({ mailboxes: [...get().mailboxes.filter((m) => !m.isShared), ...shared] });
} catch (err) {
console.warn('[email-store] shared mailbox fetch failed:', err);
}
if (drainAgain) void get().fetchMailboxes();
} catch (err) {
console.warn('[email-store] fetchMailboxes failed:', err);
if (get().activeAccountId !== activeAccountId) return;
@@ -550,7 +649,12 @@ export const useEmailStore = create<EmailState>()(
if (cacheStore.totalCount() > 0) {
try {
const limit = useSettingsStore.getState().emailsPerPage;
seededEmails = await cacheStore.getEmailsInMailbox(mailboxId, Math.max(limit, 50));
// Cached messages carry raw JMAP mailboxIds, so look up by the
// unprefixed id rather than the sidebar's shared-folder key.
seededEmails = await cacheStore.getEmailsInMailbox(
rawMailboxId(state.mailboxes, mailboxId),
Math.max(limit, 50),
);
seededTotal = seededEmails.length;
} catch (err) {
console.warn('[email-store] cache seed failed:', err);
@@ -590,15 +694,17 @@ export const useEmailStore = create<EmailState>()(
set({ loading: true });
try {
const filter = buildJmapFilter(currentMailboxId, searchQuery, filters);
const ref = refFor(get().mailboxes, currentMailboxId);
const filter = buildJmapFilter(ref.id, searchQuery, filters);
const limit = useSettingsStore.getState().emailsPerPage;
const { ids } = await queryEmails(currentMailboxId, {
const { ids } = await queryEmails(ref.id, {
position: emails.length,
limit,
filter,
accountId: ref.accountId,
});
if (get().activeAccountId !== activeAccountId || get().currentMailboxId !== currentMailboxId) return;
const newEmails = ids.length > 0 ? await fetchEmailsChunked(ids) : [];
const newEmails = ids.length > 0 ? await fetchEmailsChunked(ids, ref.accountId) : [];
if (get().activeAccountId !== activeAccountId || get().currentMailboxId !== currentMailboxId) return;
const merged = [...emails, ...newEmails];
const updates: Partial<EmailState> = { emails: merged, loading: false };
@@ -624,6 +730,9 @@ export const useEmailStore = create<EmailState>()(
// import time (that native dep can't load in the test/SSR environment).
const { uploadBytes } = await import('../api/blob');
const { expandImportableEml } = await import('../lib/eml-import');
// Both the blob upload and the import have to target the folder's owning
// account, or the import references a blob the server can't see.
const ref = refFor(get().mailboxes, mailboxId);
let imported = 0;
let failed = 0;
for (const file of files) {
@@ -633,8 +742,8 @@ export const useEmailStore = create<EmailState>()(
if (emls.length === 0) failed += 1;
for (const eml of emls) {
try {
const { blobId } = await uploadBytes(eml.bytes, 'message/rfc822');
await importEmailBlob(blobId, mailboxId);
const { blobId } = await uploadBytes(eml.bytes, 'message/rfc822', ref.accountId);
await importEmailBlob(blobId, ref.id, undefined, ref.accountId);
imported += 1;
} catch {
failed += 1;
@@ -653,12 +762,16 @@ export const useEmailStore = create<EmailState>()(
refreshEmails: async () => {
const state = get();
const { currentMailboxId, searchQuery, filters, emails: existing, emailState, activeAccountId } = state;
const { currentMailboxId, searchQuery, filters, emails: existing, activeAccountId } = state;
if (!currentMailboxId) return;
if (!jmapClientServesActiveAccount(activeAccountId)) return;
set({ loading: true, error: null });
const filter = buildJmapFilter(currentMailboxId, searchQuery, filters);
// A shared (group account) folder is queried against its owning account
// with its unprefixed id; own folders resolve to no override at all.
const ref = refFor(state.mailboxes, currentMailboxId);
const emailState = state.emailStates[stateKey(ref.accountId)];
const filter = buildJmapFilter(ref.id, searchQuery, filters);
const limit = useSettingsStore.getState().emailsPerPage;
const baseView = isBaseView(searchQuery, filters);
@@ -692,8 +805,9 @@ export const useEmailStore = create<EmailState>()(
snap.emails.length >= Math.min(limit, snap.total)
) {
const baseEmails = snap.emails;
const queryChanges = await getEmailQueryChanges(currentMailboxId, snap.queryState, {
const queryChanges = await getEmailQueryChanges(ref.id, snap.queryState, {
filter: undefined,
accountId: ref.accountId,
});
if (queryChanges) {
// What's in the visible window now: drop removed ids, then apply
@@ -709,7 +823,7 @@ export const useEmailStore = create<EmailState>()(
let destroyedExtra: string[] = [];
let nextEmailState: string | undefined = emailState;
if (emailState) {
const ec = await getEmailChanges(emailState);
const ec = await getEmailChanges(emailState, undefined, ref.accountId);
if (ec) {
updatedIds = ec.updated;
destroyedExtra = ec.destroyed;
@@ -732,7 +846,7 @@ export const useEmailStore = create<EmailState>()(
let fetchState: string | undefined;
let fetched: Email[] = [];
if (idsToFetch.length > 0) {
const res = await getEmailsWithState(idsToFetch);
const res = await getEmailsWithState(idsToFetch, ref.accountId);
fetched = res.list;
fetchState = res.state;
}
@@ -768,7 +882,11 @@ export const useEmailStore = create<EmailState>()(
emails: trimmed,
totalEmails: nextTotal,
queryState: nextQueryState,
emailState: nextEmailState ?? fetchState ?? emailState,
emailStates: withEmailState(
get().emailStates,
ref.accountId,
nextEmailState ?? fetchState ?? emailState,
),
loading: false,
mailboxSnapshots: {
...get().mailboxSnapshots,
@@ -788,9 +906,9 @@ export const useEmailStore = create<EmailState>()(
// Full re-query path. Used when there's no prior queryState, when the
// user has search/filters active (queryState only tracks the base
// query), or when the server returned cannotCalculateChanges above.
const queryRes = await queryEmails(currentMailboxId, { limit, filter });
const queryRes = await queryEmails(ref.id, { limit, filter, accountId: ref.accountId });
const fetched = queryRes.ids.length > 0
? await getEmailsWithState(queryRes.ids)
? await getEmailsWithState(queryRes.ids, ref.accountId)
: { list: [], state: undefined as string | undefined };
if (viewChanged()) return;
@@ -802,7 +920,7 @@ export const useEmailStore = create<EmailState>()(
};
if (baseView) {
updates.queryState = queryRes.queryState;
updates.emailState = fetched.state;
updates.emailStates = withEmailState(get().emailStates, ref.accountId, fetched.state);
updates.mailboxSnapshots = {
...get().mailboxSnapshots,
[currentMailboxId]: {
@@ -825,7 +943,7 @@ export const useEmailStore = create<EmailState>()(
if (!cacheStore.hydrated) await cacheStore.hydrate();
if (cacheStore.totalCount() > 0) {
const cached = await cacheStore.getEmailsInMailbox(
currentMailboxId,
ref.id,
Math.max(limit, 50),
);
if (
@@ -854,12 +972,26 @@ export const useEmailStore = create<EmailState>()(
// currently showing (e.g. push notifications received during/just after
// an account switch).
if (!jmapClientServesActiveAccount(get().activeAccountId)) return;
const accountId = jmapClient.accountId;
const accountChanges = change.changed?.[accountId];
if (!accountChanges) return;
// Push/EventSource state changes cover every account in the session, so a
// shared (group account) mailbox reports under its own account id. Fold
// them all in: any account's Mailbox change refreshes the folder list, but
// only the account behind the open folder needs its message list re-read.
const primaryId = jmapClient.accountId;
const state = get();
const currentAccountId =
state.currentMailboxId
? refFor(state.mailboxes, state.currentMailboxId).accountId ?? primaryId
: primaryId;
const known = new Set([primaryId, ...jmapClient.getSharedMailAccounts().map((a) => a.id)]);
const mailboxChanged = 'Mailbox' in accountChanges;
const emailChanged = 'Email' in accountChanges || 'EmailDelivery' in accountChanges;
let mailboxChanged = false;
let emailChanged = false;
for (const [accountId, accountChanges] of Object.entries(change.changed ?? {})) {
if (!known.has(accountId) || !accountChanges) continue;
if ('Mailbox' in accountChanges) mailboxChanged = true;
if (accountId !== currentAccountId) continue;
if ('Email' in accountChanges || 'EmailDelivery' in accountChanges) emailChanged = true;
}
if (!mailboxChanged && !emailChanged) return;
if (mailboxChanged) {
@@ -925,7 +1057,8 @@ export const useEmailStore = create<EmailState>()(
},
markRead: async (emailId, accountId) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
const nextKeywords = { ...(email?.keywords ?? {}), $seen: true };
// A group/shared message opened from the unified inbox lives under another
// JMAP account and isn't in the active list/cache or the (account-scoped)
@@ -934,7 +1067,8 @@ export const useEmailStore = create<EmailState>()(
await setEmailKeywords(emailId, nextKeywords, accountId);
return;
}
await applyOrQueue({ kind: 'keywords', emailId, keywords: nextKeywords });
const owner = accountId ?? currentAccountId(state);
await applyOrQueue({ kind: 'keywords', emailId, accountId: owner, keywords: nextKeywords });
set({
emails: get().emails.map((e) =>
e.id === emailId ? { ...e, keywords: nextKeywords } : e,
@@ -944,10 +1078,16 @@ export const useEmailStore = create<EmailState>()(
},
markUnread: async (emailId) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
if (!email) return;
const { $seen, ...rest } = email.keywords;
await applyOrQueue({ kind: 'keywords', emailId, keywords: rest });
await applyOrQueue({
kind: 'keywords',
emailId,
accountId: currentAccountId(state),
keywords: rest,
});
set({
emails: get().emails.map((e) =>
e.id === emailId ? { ...e, keywords: rest } : e,
@@ -957,7 +1097,8 @@ export const useEmailStore = create<EmailState>()(
},
toggleStar: async (emailId, starred) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
if (!email) return;
const keywords = { ...email.keywords };
if (starred) {
@@ -965,7 +1106,12 @@ export const useEmailStore = create<EmailState>()(
} else {
delete keywords.$flagged;
}
await applyOrQueue({ kind: 'keywords', emailId, keywords });
await applyOrQueue({
kind: 'keywords',
emailId,
accountId: currentAccountId(state),
keywords,
});
set({
emails: get().emails.map((e) =>
e.id === emailId ? { ...e, keywords } : e,
@@ -975,7 +1121,8 @@ export const useEmailStore = create<EmailState>()(
},
togglePin: async (emailId, pinned) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
if (!email) return;
const keywords = { ...email.keywords };
if (pinned) {
@@ -983,7 +1130,12 @@ export const useEmailStore = create<EmailState>()(
} else {
delete keywords.$important;
}
await applyOrQueue({ kind: 'keywords', emailId, keywords });
await applyOrQueue({
kind: 'keywords',
emailId,
accountId: currentAccountId(state),
keywords,
});
set({
emails: get().emails.map((e) =>
e.id === emailId ? { ...e, keywords } : e,
@@ -993,13 +1145,23 @@ export const useEmailStore = create<EmailState>()(
},
moveToMailbox: async (emailId, fromMailboxId, toMailboxId) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
const from = refFor(state.mailboxes, fromMailboxId);
const to = refFor(state.mailboxes, toMailboxId);
// A single Email/set is scoped to one account, so there's no move between
// the user's own folders and a shared account's (or between two shared
// accounts) — that would be a copy-then-delete across accounts.
if (from.accountId !== to.accountId) {
set({ error: 'Messages can only be moved within the same account' });
return;
}
const original = email ? { ...email.mailboxIds } : null;
const target = mailboxesAfterMove(email?.mailboxIds, fromMailboxId, toMailboxId);
const target = mailboxesAfterMove(email?.mailboxIds, from.id, to.id);
await applyOrQueue(
{ kind: 'mailboxes', emailId, mailboxIds: target },
() => moveEmail(emailId, fromMailboxId, toMailboxId),
{ kind: 'mailboxes', emailId, accountId: from.accountId, mailboxIds: target },
() => moveEmail(emailId, from.id, to.id, from.accountId),
);
set({ emails: get().emails.filter((e) => e.id !== emailId) });
patchCache(emailId, { mailboxIds: target });
@@ -1011,6 +1173,7 @@ export const useEmailStore = create<EmailState>()(
kind: 'move',
label: targetName ? `Email moved to ${targetName}` : 'Email moved',
createdAt: Date.now(),
accountId: from.accountId,
items: [{ email, originalMailboxIds: original }],
},
});
@@ -1018,15 +1181,19 @@ export const useEmailStore = create<EmailState>()(
},
archiveEmail: async (emailId) => {
const { emails, mailboxes } = get();
const email = emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
if (!email) return;
const archiveMailbox = mailboxes.find(
// Archive into the *same account's* Archive folder — a shared mailbox's
// messages can't be filed into the user's own.
const scoped = mailboxesForSiblingOf(state.mailboxes, state.currentMailboxId);
const archiveMailbox = scoped.find(
(m) => m.role === 'archive' || m.name.toLowerCase() === 'archive',
);
if (!archiveMailbox) return;
if (email.mailboxIds?.[archiveMailbox.id]) return;
const archive = refFor(state.mailboxes, archiveMailbox.id);
if (email.mailboxIds?.[archive.id]) return;
const mode = useSettingsStore.getState().archiveMode;
const original = { ...email.mailboxIds };
@@ -1035,12 +1202,18 @@ export const useEmailStore = create<EmailState>()(
// archive root (we can't create folders without a connection); the queued
// op replays as a plain move into Archive.
const { queued } = await applyOrQueue(
{ kind: 'mailboxes', emailId, mailboxIds: { [archiveMailbox.id]: true } },
{
kind: 'mailboxes',
emailId,
accountId: archive.accountId,
mailboxIds: { [archive.id]: true },
},
() => apiArchiveEmails(
[{ id: email.id, receivedAt: email.receivedAt }],
archiveMailbox.id,
archive.id,
mode,
mailboxes,
toRawMailboxes(scoped),
archive.accountId,
),
);
@@ -1050,10 +1223,11 @@ export const useEmailStore = create<EmailState>()(
kind: 'archive',
label: 'Email archived',
createdAt: Date.now(),
accountId: archive.accountId,
items: [{ email, originalMailboxIds: original }],
},
});
patchCache(emailId, { mailboxIds: { [archiveMailbox.id]: true } });
patchCache(emailId, { mailboxIds: { [archive.id]: true } });
// Auto-sort modes may have created new year/month folders - refresh the
// mailbox list so the sidebar picks them up on the next render. Skip when
@@ -1064,12 +1238,16 @@ export const useEmailStore = create<EmailState>()(
},
deleteEmail: async (emailId, trashMailboxId, currentMailboxId) => {
const email = get().emails.find((e) => e.id === emailId);
const state = get();
const email = state.emails.find((e) => e.id === emailId);
const original = email ? { ...email.mailboxIds } : null;
const settings = useSettingsStore.getState();
const { mailboxes } = get();
const junkMailbox = mailboxes.find((m) => m.role === 'junk' || m.role === 'spam');
const inJunk = !!(junkMailbox && email?.mailboxIds?.[junkMailbox.id]);
const trash = refFor(state.mailboxes, trashMailboxId);
const source = refFor(state.mailboxes, currentMailboxId);
const junkMailbox = mailboxesForSiblingOf(state.mailboxes, currentMailboxId)
.find((m) => m.role === 'junk' || m.role === 'spam');
const junkId = junkMailbox ? rawMailboxId(state.mailboxes, junkMailbox.id) : null;
const inJunk = !!(junkId && email?.mailboxIds?.[junkId]);
const inTrash = currentMailboxId === trashMailboxId;
// Resolve effective destination:
@@ -1086,21 +1264,26 @@ export const useEmailStore = create<EmailState>()(
// Use the trash mailbox as the "current" so apiDeleteEmail takes the
// destroy branch even when the source folder isn't trash.
await applyOrQueue(
{ kind: 'destroy', emailId },
() => apiDeleteEmail(emailId, trashMailboxId, trashMailboxId),
{ kind: 'destroy', emailId, accountId: trash.accountId },
() => apiDeleteEmail(emailId, trash.id, trash.id, trash.accountId),
);
dropFromCache([emailId]);
} else {
const target = mailboxesAfterMove(email?.mailboxIds, currentMailboxId, trashMailboxId);
const target = mailboxesAfterMove(email?.mailboxIds, source.id, trash.id);
await applyOrQueue(
{ kind: 'mailboxes', emailId, mailboxIds: target },
() => apiDeleteEmail(emailId, trashMailboxId, currentMailboxId),
{ kind: 'mailboxes', emailId, accountId: source.accountId, mailboxIds: target },
() => apiDeleteEmail(emailId, trash.id, source.id, source.accountId),
);
// "Move to Trash and mark as read" (#323): when the user picked that
// delete action, also clear unread state for messages moved to trash.
if (settings.deleteAction === 'trash-and-read' && email && !email.keywords?.$seen) {
const nextKeywords = { ...email.keywords, $seen: true };
await applyOrQueue({ kind: 'keywords', emailId, keywords: nextKeywords });
await applyOrQueue({
kind: 'keywords',
emailId,
accountId: source.accountId,
keywords: nextKeywords,
});
patchCache(emailId, { mailboxIds: target, keywords: nextKeywords });
} else {
patchCache(emailId, { mailboxIds: target });
@@ -1116,6 +1299,7 @@ export const useEmailStore = create<EmailState>()(
kind: 'delete',
label: 'Email moved to Trash',
createdAt: Date.now(),
accountId: source.accountId,
items: [{ email, originalMailboxIds: original }],
},
});
@@ -1127,27 +1311,35 @@ export const useEmailStore = create<EmailState>()(
// so a multi-select archive/move/delete is reversed with one snackbar tap.
archiveEmailsBatch: async (emailIds) => {
const { emails, mailboxes } = get();
const archiveMailbox = mailboxes.find(
const state = get();
const scoped = mailboxesForSiblingOf(state.mailboxes, state.currentMailboxId);
const archiveMailbox = scoped.find(
(m) => m.role === 'archive' || m.name.toLowerCase() === 'archive',
);
if (!archiveMailbox) return;
const targets = emails.filter(
(e) => emailIds.includes(e.id) && !e.mailboxIds?.[archiveMailbox.id],
const archive = refFor(state.mailboxes, archiveMailbox.id);
const targets = state.emails.filter(
(e) => emailIds.includes(e.id) && !e.mailboxIds?.[archive.id],
);
if (targets.length === 0) return;
const mode = useSettingsStore.getState().archiveMode;
const items = targets.map((e) => ({ email: e, originalMailboxIds: { ...e.mailboxIds } }));
const archiveTarget = { [archiveMailbox.id]: true };
const archiveTarget = { [archive.id]: true };
const { queued } = await applyOrQueueBatch(
targets.map((e): OutboxOp => ({ kind: 'mailboxes', emailId: e.id, mailboxIds: archiveTarget })),
targets.map((e): OutboxOp => ({
kind: 'mailboxes',
emailId: e.id,
accountId: archive.accountId,
mailboxIds: archiveTarget,
})),
() => apiArchiveEmails(
targets.map((e) => ({ id: e.id, receivedAt: e.receivedAt })),
archiveMailbox.id,
archive.id,
mode,
mailboxes,
toRawMailboxes(scoped),
archive.accountId,
),
);
@@ -1158,6 +1350,7 @@ export const useEmailStore = create<EmailState>()(
kind: 'archive',
label: targets.length === 1 ? 'Email archived' : `${targets.length} emails archived`,
createdAt: Date.now(),
accountId: archive.accountId,
items,
},
});
@@ -1169,6 +1362,13 @@ export const useEmailStore = create<EmailState>()(
moveEmailsToMailbox: async (emailIds, toMailboxId) => {
const { emails, currentMailboxId, mailboxes } = get();
if (!currentMailboxId || toMailboxId === currentMailboxId) return;
const source = refFor(mailboxes, currentMailboxId);
const to = refFor(mailboxes, toMailboxId);
// See moveToMailbox: one Email/set can't span two accounts.
if (source.accountId !== to.accountId) {
set({ error: 'Messages can only be moved within the same account' });
return;
}
const targets = emails.filter((e) => emailIds.includes(e.id));
if (targets.length === 0) return;
@@ -1178,14 +1378,15 @@ export const useEmailStore = create<EmailState>()(
targets.map((e): OutboxOp => ({
kind: 'mailboxes',
emailId: e.id,
mailboxIds: mailboxesAfterMove(e.mailboxIds, currentMailboxId, toMailboxId),
accountId: source.accountId,
mailboxIds: mailboxesAfterMove(e.mailboxIds, source.id, to.id),
})),
() => apiMoveEmails(targets.map((e) => e.id), currentMailboxId, toMailboxId),
() => apiMoveEmails(targets.map((e) => e.id), source.id, to.id, source.accountId),
);
const removed = new Set(targets.map((e) => e.id));
for (const e of targets) {
patchCache(e.id, { mailboxIds: mailboxesAfterMove(e.mailboxIds, currentMailboxId, toMailboxId) });
patchCache(e.id, { mailboxIds: mailboxesAfterMove(e.mailboxIds, source.id, to.id) });
}
const targetName = mailboxes.find((m) => m.id === toMailboxId)?.name;
set({
@@ -1196,6 +1397,7 @@ export const useEmailStore = create<EmailState>()(
? `${targets.length === 1 ? 'Email' : `${targets.length} emails`} moved to ${targetName}`
: 'Emails moved',
createdAt: Date.now(),
accountId: source.accountId,
items,
},
});
@@ -1204,7 +1406,11 @@ export const useEmailStore = create<EmailState>()(
deleteEmailsBatch: async (emailIds, trashMailboxId, currentMailboxId) => {
const { emails, mailboxes } = get();
const settings = useSettingsStore.getState();
const junkMailbox = mailboxes.find((m) => m.role === 'junk' || m.role === 'spam');
const trash = refFor(mailboxes, trashMailboxId);
const source = refFor(mailboxes, currentMailboxId);
const junkMailbox = mailboxesForSiblingOf(mailboxes, currentMailboxId)
.find((m) => m.role === 'junk' || m.role === 'spam');
const junkId = junkMailbox ? rawMailboxId(mailboxes, junkMailbox.id) : null;
const inTrash = currentMailboxId === trashMailboxId;
const targets = emails.filter((e) => emailIds.includes(e.id));
if (targets.length === 0) return;
@@ -1215,7 +1421,7 @@ export const useEmailStore = create<EmailState>()(
const toDestroy: Email[] = [];
const toTrash: Email[] = [];
for (const e of targets) {
const inJunk = !!(junkMailbox && e.mailboxIds?.[junkMailbox.id]);
const inJunk = !!(junkId && e.mailboxIds?.[junkId]);
const destroy =
inTrash ||
settings.deleteAction === 'permanent' ||
@@ -1234,28 +1440,35 @@ export const useEmailStore = create<EmailState>()(
);
const ops: OutboxOp[] = [
...toDestroy.map((e): OutboxOp => ({ kind: 'destroy', emailId: e.id })),
...toDestroy.map((e): OutboxOp => ({
kind: 'destroy',
emailId: e.id,
accountId: trash.accountId,
})),
...toTrash.map((e): OutboxOp => ({
kind: 'mailboxes',
emailId: e.id,
mailboxIds: mailboxesAfterMove(e.mailboxIds, currentMailboxId, trashMailboxId),
accountId: source.accountId,
mailboxIds: mailboxesAfterMove(e.mailboxIds, source.id, trash.id),
})),
...toMarkRead.map((e): OutboxOp => ({
kind: 'keywords',
emailId: e.id,
accountId: source.accountId,
keywords: markReadKeywords.get(e.id)!,
})),
];
await applyOrQueueBatch(ops, async () => {
if (toDestroy.length > 0) {
await apiDeleteEmails(toDestroy.map((e) => e.id), trashMailboxId, trashMailboxId);
await apiDeleteEmails(toDestroy.map((e) => e.id), trash.id, trash.id, trash.accountId);
}
if (toTrash.length > 0) {
await apiMoveEmails(toTrash.map((e) => e.id), currentMailboxId, trashMailboxId);
await apiMoveEmails(toTrash.map((e) => e.id), source.id, trash.id, source.accountId);
}
if (toMarkRead.length > 0) {
await setKeywordsForEmails(
toMarkRead.map((e) => ({ id: e.id, keywords: markReadKeywords.get(e.id)! })),
source.accountId,
);
}
});
@@ -1263,7 +1476,7 @@ export const useEmailStore = create<EmailState>()(
if (toDestroy.length > 0) dropFromCache(toDestroy.map((e) => e.id));
for (const e of toTrash) {
patchCache(e.id, {
mailboxIds: mailboxesAfterMove(e.mailboxIds, currentMailboxId, trashMailboxId),
mailboxIds: mailboxesAfterMove(e.mailboxIds, source.id, trash.id),
...(markReadKeywords.has(e.id) ? { keywords: markReadKeywords.get(e.id) } : {}),
});
}
@@ -1278,6 +1491,7 @@ export const useEmailStore = create<EmailState>()(
kind: 'delete',
label: toTrash.length === 1 ? 'Email moved to Trash' : `${toTrash.length} emails moved to Trash`,
createdAt: Date.now(),
accountId: source.accountId,
items: toTrash.map((e) => ({ email: e, originalMailboxIds: { ...e.mailboxIds } })),
},
});
@@ -1285,8 +1499,10 @@ export const useEmailStore = create<EmailState>()(
},
setKeywordForEmails: async (emailIds, token, on) => {
const targets = get().emails.filter((e) => emailIds.includes(e.id));
const state = get();
const targets = state.emails.filter((e) => emailIds.includes(e.id));
if (targets.length === 0) return;
const owner = currentAccountId(state);
const updates = targets.map((e) => {
const keywords = { ...e.keywords };
if (on) keywords[token] = true;
@@ -1294,8 +1510,13 @@ export const useEmailStore = create<EmailState>()(
return { id: e.id, keywords };
});
await applyOrQueueBatch(
updates.map((u): OutboxOp => ({ kind: 'keywords', emailId: u.id, keywords: u.keywords })),
() => setKeywordsForEmails(updates),
updates.map((u): OutboxOp => ({
kind: 'keywords',
emailId: u.id,
accountId: owner,
keywords: u.keywords,
})),
() => setKeywordsForEmails(updates, owner),
);
const byId = new Map(updates.map((u) => [u.id, u.keywords]));
set({
@@ -1316,10 +1537,12 @@ export const useEmailStore = create<EmailState>()(
entry.items.map((it): OutboxOp => ({
kind: 'mailboxes',
emailId: it.email.id,
accountId: entry.accountId,
mailboxIds: it.originalMailboxIds,
})),
() => restoreEmailMailboxes(
entry.items.map((it) => ({ id: it.email.id, mailboxIds: it.originalMailboxIds })),
entry.accountId,
),
);
for (const it of entry.items) {
@@ -1333,10 +1556,11 @@ export const useEmailStore = create<EmailState>()(
// Re-insert each restored email into the visible list if its original
// mailboxIds include the current view. Server is the source of truth for
// ordering, but local re-insertion gives the user instant feedback.
const { currentMailboxId, emails } = get();
const { currentMailboxId, emails, mailboxes } = get();
if (currentMailboxId) {
const currentRawId = rawMailboxId(mailboxes, currentMailboxId);
const restored = entry.items
.filter((it) => it.originalMailboxIds[currentMailboxId])
.filter((it) => it.originalMailboxIds[currentRawId])
.map((it) => ({ ...it.email, mailboxIds: it.originalMailboxIds }));
if (restored.length > 0) {
const merged = [...restored, ...emails].sort(
@@ -1350,15 +1574,18 @@ export const useEmailStore = create<EmailState>()(
clearUndo: () => set({ pendingUndo: null }),
searchEmails: async (query) => {
const ids = await apiSearchEmails(query);
// Search the account whose folder is open, so a shared mailbox searches
// its own messages rather than the user's.
const owner = currentAccountId(get());
const ids = await apiSearchEmails(query, undefined, 30, owner);
if (ids.length === 0) return [];
return fetchEmails(ids);
return fetchEmails(ids, owner);
},
reset: () => set({
mailboxes: [],
mailboxState: undefined,
emailState: undefined,
emailStates: {},
currentMailboxId: null,
mailboxSnapshots: {},
emails: [],
@@ -1377,19 +1604,39 @@ export const useEmailStore = create<EmailState>()(
// refresh once the session is ready.
name: 'email-cache',
storage: createJSONStorage(() => AsyncStorage),
version: 1,
version: 2,
// v0 → v1: drop every cached queryState. Pre-v1 builds could persist a
// search-result list next to the base view's queryState, and the
// incremental sync path would then "confirm" those search results as
// the whole mailbox and bake them into the snapshot (issue #10).
// Without a queryState the next refresh does a full re-query, which
// rebuilds any poisoned window from the server.
//
// v1 → v2: the single `emailState` became `emailStates`, keyed per JMAP
// account so shared (group account) folders track their own. The old
// token is dropped; the next refresh re-primes it from Email/get.
migrate: (persisted, version) => {
if (version >= 1) return persisted as EmailState;
const s = persisted as Pick<
EmailState,
'accountSnapshots' | 'mailboxSnapshots' | 'queryState'
> & Record<string, unknown>;
const dropEmailState = (input: Record<string, unknown>): Record<string, unknown> => {
const { emailState: _drop, ...rest } = input;
return { ...rest, emailStates: {} };
};
if (version >= 2) return persisted as EmailState;
if (version >= 1) {
const accountSnapshots: Record<string, AccountSnapshot> = {};
for (const [id, acc] of Object.entries(s.accountSnapshots ?? {})) {
accountSnapshots[id] = dropEmailState(
acc as unknown as Record<string, unknown>,
) as unknown as AccountSnapshot;
}
return { ...dropEmailState(s), accountSnapshots } as unknown as EmailState;
}
const stripQueryStates = (
snaps: Record<string, MailboxSnapshot> | undefined,
): Record<string, MailboxSnapshot> =>
@@ -1401,13 +1648,13 @@ export const useEmailStore = create<EmailState>()(
);
const accountSnapshots: Record<string, AccountSnapshot> = {};
for (const [id, acc] of Object.entries(s.accountSnapshots ?? {})) {
accountSnapshots[id] = {
accountSnapshots[id] = dropEmailState({
...acc,
mailboxSnapshots: stripQueryStates(acc.mailboxSnapshots),
};
}) as unknown as AccountSnapshot;
}
return {
...s,
...dropEmailState(s),
accountSnapshots,
mailboxSnapshots: stripQueryStates(s.mailboxSnapshots),
queryState: undefined,
@@ -1418,7 +1665,7 @@ export const useEmailStore = create<EmailState>()(
activeAccountId: state.activeAccountId,
mailboxes: state.mailboxes,
mailboxState: state.mailboxState,
emailState: state.emailState,
emailStates: state.emailStates,
currentMailboxId: state.currentMailboxId,
mailboxSnapshots: state.mailboxSnapshots,
emails: state.emails,
src/stores/outbox-store.ts
+16 -10
View File
@@ -34,10 +34,13 @@ function storageKey(accountId: string): string {
return `${KEY_PREFIX}${accountId}`;
}
// `accountId` is the JMAP account the message lives under. Absent for the
// user's own mail (the client's primary account); set when the message belongs
// to a shared/group account, so replay after a reconnect still targets it.
export type OutboxOp =
| { kind: 'keywords'; emailId: string; keywords: Record<string, boolean> }
| { kind: 'mailboxes'; emailId: string; mailboxIds: Record<string, boolean> }
| { kind: 'destroy'; emailId: string };
| { kind: 'keywords'; emailId: string; accountId?: string; keywords: Record<string, boolean> }
| { kind: 'mailboxes'; emailId: string; accountId?: string; mailboxIds: Record<string, boolean> }
| { kind: 'destroy'; emailId: string; accountId?: string };
export interface OutboxEntry {
id: string;
@@ -85,11 +88,11 @@ async function load(accountId: string): Promise<OutboxEntry[]> {
async function runOp(op: OutboxOp): Promise<void> {
switch (op.kind) {
case 'keywords':
return setEmailKeywords(op.emailId, op.keywords);
return setEmailKeywords(op.emailId, op.keywords, op.accountId);
case 'mailboxes':
return setEmailMailboxes(op.emailId, op.mailboxIds);
return setEmailMailboxes(op.emailId, op.mailboxIds, op.accountId);
case 'destroy':
return destroyEmails([op.emailId]);
return destroyEmails([op.emailId], op.accountId);
}
}
@@ -136,20 +139,23 @@ export const useOutboxStore = create<OutboxState>((set, get) => ({
return;
}
let entries = [...get().entries];
const { emailId } = op;
// Message identity is (account, id): JMAP ids are only unique within an
// account, and the queue can hold ops for shared accounts alongside own.
const sameMessage = (other: OutboxOp) =>
other.emailId === op.emailId && other.accountId === op.accountId;
if (op.kind === 'destroy') {
// Destroy is terminal — drop any pending edits for this message and
// append the destroy so it runs last.
entries = entries.filter((e) => e.op.emailId !== emailId);
entries = entries.filter((e) => !sameMessage(e.op));
entries.push({ id: generateUUID(), op, createdAt: Date.now(), attempts: 0 });
} else {
// A queued destroy wins; further edits to a doomed message are pointless.
if (entries.some((e) => e.op.emailId === emailId && e.op.kind === 'destroy')) return;
if (entries.some((e) => sameMessage(e.op) && e.op.kind === 'destroy')) return;
// Coalesce: replace any pending op of the same kind for this message
// (full-state replace makes the latest one authoritative). Keep its
// position so creation order is preserved for replay.
const idx = entries.findIndex((e) => e.op.emailId === emailId && e.op.kind === op.kind);
const idx = entries.findIndex((e) => sameMessage(e.op) && e.op.kind === op.kind);
if (idx >= 0) {
entries[idx] = { ...entries[idx], op, attempts: 0, lastError: undefined };
} else {