@marcoappio/marco-config 2.0.540 → 2.0.542

package/dist/zero/mutators.test.js

@@ -1,1158 +0,0 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test';
-import * as v from 'valibot';
-import { CustomViewIcon, USER_SETTINGS_CUSTOM_VIEW_ICONS } from '../types';
-import { mutatorSchemas } from './mutatorSchemas';
-import { mutators } from './mutators';
-const createMockTx = () => ({
-    mutate: {
-        account: {
-            delete: mock(() => Promise.resolve()),
-            insert: mock(() => Promise.resolve()),
-            update: mock(() => Promise.resolve()),
-        },
-        accountAlias: {
-            delete: mock(() => Promise.resolve()),
-            insert: mock(() => Promise.resolve()),
-            update: mock(() => Promise.resolve()),
-        },
-        accountLabel: { update: mock(() => Promise.resolve()) },
-        draft: {
-            delete: mock(() => Promise.resolve()),
-            insert: mock(() => Promise.resolve()),
-            update: mock(() => Promise.resolve()),
-        },
-        draftAttachment: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
-        thread: { delete: mock(() => Promise.resolve()), update: mock(() => Promise.resolve()) },
-        threadByLabel: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
-        threadLabel: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
-        user: { update: mock(() => Promise.resolve()) },
-        userPushNotificationToken: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
-    },
-    run: mock(() => Promise.resolve(null)),
-});
-describe('mutators', () => {
-    let tx;
-    const ctx = { userId: 'test-user-id' };
-    beforeEach(() => {
-        tx = createMockTx();
-    });
-    describe('account', () => {
-        describe('createAccount', () => {
-            it('creates an account and primary alias', async () => {
-                const args = {
-                    aliasId: 'test-alias-id-1',
-                    color: '#ff0000',
-                    emailAddress: 'test@example.com',
-                    id: 'test-account-id-1',
-                };
-                await mutators.account.createAccount.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.insert).toHaveBeenCalledWith({
-                    color: '#ff0000',
-                    displayName: null,
-                    id: 'test-account-id-1',
-                    imapConnectionStatus: 'AWAITING_CONNECTION',
-                    mailProcessedCount: 0,
-                    mailTotalCount: 0,
-                    primaryAliasId: 'test-alias-id-1',
-                    userId: 'test-user-id',
-                });
-                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-1',
-                    emailAddress: 'test@example.com',
-                    id: 'test-alias-id-1',
-                    isPrimary: true,
-                    name: null,
-                });
-            });
-        });
-        describe('createAlias', () => {
-            it('creates a non-primary alias', async () => {
-                const args = {
-                    accountId: 'test-account-id-1',
-                    alias: {
-                        emailAddress: 'alias@example.com',
-                        id: 'test-alias-id-2',
-                        name: 'test-alias-name',
-                    },
-                };
-                await mutators.account.createAlias.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-1',
-                    emailAddress: 'alias@example.com',
-                    id: 'test-alias-id-2',
-                    isPrimary: false,
-                    name: 'test-alias-name',
-                });
-            });
-            it('creates an alias with null name', async () => {
-                const args = {
-                    accountId: 'test-account-id-1',
-                    alias: {
-                        emailAddress: 'alias@example.com',
-                        id: 'test-alias-id-2',
-                        name: null,
-                    },
-                };
-                await mutators.account.createAlias.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-1',
-                    emailAddress: 'alias@example.com',
-                    id: 'test-alias-id-2',
-                    isPrimary: false,
-                    name: null,
-                });
-            });
-        });
-        describe('deleteAccount', () => {
-            it('deletes an account', async () => {
-                const args = { id: 'test-account-id-1' };
-                await mutators.account.deleteAccount.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.delete).toHaveBeenCalledWith({ id: 'test-account-id-1' });
-            });
-        });
-        describe('deleteAlias', () => {
-            it('deletes a non-primary alias', async () => {
-                tx.run = mock(() => Promise.resolve({ isPrimary: false }));
-                const args = { accountId: 'test-account-id-1', aliasId: 'test-alias-id-2' };
-                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.delete).toHaveBeenCalledWith({ id: 'test-alias-id-2' });
-                expect(tx.mutate.accountAlias.update).not.toHaveBeenCalled();
-            });
-            it('promotes another alias when deleting primary', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce({ isPrimary: true })
-                    .mockResolvedValueOnce([{ id: 'test-alias-id-3' }]);
-                const args = { accountId: 'test-account-id-1', aliasId: 'test-alias-id-1' };
-                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.delete).toHaveBeenCalledWith({ id: 'test-alias-id-1' });
-                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'test-alias-id-3', isPrimary: true });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({
-                    id: 'test-account-id-1',
-                    primaryAliasId: 'test-alias-id-3',
-                });
-            });
-            it('sets primaryAliasId to null when no remaining aliases', async () => {
-                tx.run = mock().mockResolvedValueOnce({ isPrimary: true }).mockResolvedValueOnce([]);
-                const args = { accountId: 'test-account-id-1', aliasId: 'test-alias-id-1' };
-                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({ id: 'test-account-id-1', primaryAliasId: null });
-            });
-        });
-        describe('setAliasName', () => {
-            it('updates alias name', async () => {
-                const args = { accountId: 'test-account-id-1', aliasId: 'test-alias-id-1', displayName: 'test-alias-new-name' };
-                await mutators.account.setAliasName.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({
-                    id: 'test-alias-id-1',
-                    name: 'test-alias-new-name',
-                });
-            });
-        });
-        describe('setAliasPrimary', () => {
-            it('sets a new primary alias', async () => {
-                tx.run = mock(() => Promise.resolve([{ id: 'test-alias-id-1' }, { id: 'test-alias-id-2' }]));
-                const args = { accountId: 'test-account-id-1', aliasId: 'test-alias-id-2' };
-                await mutators.account.setAliasPrimary.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'test-alias-id-1', isPrimary: false });
-                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'test-alias-id-2', isPrimary: true });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({
-                    id: 'test-account-id-1',
-                    primaryAliasId: 'test-alias-id-2',
-                });
-            });
-        });
-        describe('setConnectionConfigImapRaw', () => {
-            it('updates connection status to awaiting', async () => {
-                const args = {
-                    connectionConfig: {
-                        imapHost: 'imap.example.com',
-                        imapPassword: 'test-imap-password',
-                        imapPort: 993,
-                        imapSocketType: 'SSL',
-                        imapUser: 'test-imap-user',
-                        smtpHost: 'smtp.example.com',
-                        smtpPassword: 'test-smtp-password',
-                        smtpPort: 465,
-                        smtpSocketType: 'SSL',
-                        smtpUser: 'test-smtp-user',
-                    },
-                    id: 'test-account-id-1',
-                };
-                await mutators.account.setConnectionConfigImapRaw.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({
-                    id: 'test-account-id-1',
-                    imapConnectionStatus: 'AWAITING_CONNECTION',
-                });
-            });
-        });
-        describe('setConnectionConfigOauth', () => {
-            it('updates connection status for oauth', async () => {
-                const args = {
-                    connectionConfig: { code: 'test-auth-code', provider: 'GOOGLE', user: 'test-user@example.com' },
-                    id: 'test-account-id-1',
-                };
-                await mutators.account.setConnectionConfigOauth.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({
-                    id: 'test-account-id-1',
-                    imapConnectionStatus: 'AWAITING_CONNECTION',
-                });
-            });
-        });
-        describe('setSettings', () => {
-            it('updates account settings', async () => {
-                const args = { color: '#00ff00', displayName: 'test-account-display-name', id: 'test-account-id-1' };
-                await mutators.account.setSettings.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.account.update).toHaveBeenCalledWith({
-                    color: '#00ff00',
-                    displayName: 'test-account-display-name',
-                    id: 'test-account-id-1',
-                });
-            });
-        });
-    });
-    describe('draft', () => {
-        describe('cancelSend', () => {
-            it('cancels a scheduled send', async () => {
-                tx.run = mock(() => Promise.resolve({ status: 'SEND_REQUESTED' }));
-                const args = { id: 'test-draft-id-1', updatedAt: 1234567890 };
-                await mutators.draft.cancelSend.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    id: 'test-draft-id-1',
-                    scheduledFor: null,
-                    status: 'DRAFT',
-                    updatedAt: 1234567890,
-                });
-            });
-            it('does nothing if draft not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = { id: 'test-draft-id-1', updatedAt: 1234567890 };
-                await mutators.draft.cancelSend.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).not.toHaveBeenCalled();
-            });
-            it('does nothing if already confirmed', async () => {
-                tx.run = mock(() => Promise.resolve({ status: 'SEND_CONFIRMED' }));
-                const args = { id: 'test-draft-id-1', updatedAt: 1234567890 };
-                await mutators.draft.cancelSend.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).not.toHaveBeenCalled();
-            });
-        });
-        describe('createAttachment', () => {
-            it('creates an attachment and updates draft', async () => {
-                const args = {
-                    attachment: {
-                        fileName: 'file.pdf',
-                        id: 'test-attachment-id-1',
-                        mimeType: 'application/pdf',
-                        status: 'PENDING',
-                        totalSize: 1024,
-                    },
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                };
-                await mutators.draft.createAttachment.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draftAttachment.insert).toHaveBeenCalledWith({
-                    draftId: 'test-draft-id-1',
-                    fileName: 'file.pdf',
-                    id: 'test-attachment-id-1',
-                    mimeType: 'application/pdf',
-                    status: 'PENDING',
-                    totalSize: 1024,
-                });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                });
-            });
-        });
-        describe('createDraft', () => {
-            it('creates a draft with attachments', async () => {
-                const args = {
-                    accountId: 'test-account-id-1',
-                    attachments: [
-                        {
-                            fileName: 'test-file-name.pdf',
-                            id: 'test-attachment-id-1',
-                            mimeType: 'application/pdf',
-                            status: 'COMPLETE',
-                            totalSize: 1024,
-                        },
-                    ],
-                    body: {
-                        bcc: [],
-                        cc: ['test-email-1@example.com'],
-                        content: 'test-content',
-                        subject: 'test-subject',
-                        to: ['test-email-2@example.com'],
-                    },
-                    error: null,
-                    from: 'test-email-3@example.com',
-                    fromName: 'test-sender-name',
-                    id: 'test-draft-id-1',
-                    referencedMessageId: null,
-                    scheduledFor: null,
-                    status: 'DRAFT',
-                    type: 'NEW',
-                    updatedAt: 1234567890,
-                };
-                await mutators.draft.createDraft.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.insert).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-1',
-                    body: {
-                        bcc: [],
-                        cc: ['test-email-1@example.com'],
-                        content: 'test-content',
-                        to: ['test-email-2@example.com'],
-                    },
-                    error: null,
-                    fromAliasId: null,
-                    fromEmail: 'test-email-3@example.com',
-                    fromName: 'test-sender-name',
-                    id: 'test-draft-id-1',
-                    referencedMessageId: null,
-                    scheduledFor: null,
-                    status: 'DRAFT',
-                    subject: 'test-subject',
-                    type: 'NEW',
-                    updatedAt: 1234567890,
-                    userId: 'test-user-id',
-                });
-                expect(tx.mutate.draftAttachment.insert).toHaveBeenCalledWith({
-                    draftId: 'test-draft-id-1',
-                    fileName: 'test-file-name.pdf',
-                    id: 'test-attachment-id-1',
-                    mimeType: 'application/pdf',
-                    status: 'COMPLETE',
-                    totalSize: 1024,
-                });
-            });
-        });
-        describe('deleteAttachment', () => {
-            it('deletes an attachment and updates draft', async () => {
-                const args = { attachmentId: 'test-attachment-id-1', id: 'test-draft-id-1', updatedAt: 1234567890 };
-                await mutators.draft.deleteAttachment.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draftAttachment.delete).toHaveBeenCalledWith({ id: 'test-attachment-id-1' });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({ id: 'test-draft-id-1', updatedAt: 1234567890 });
-            });
-        });
-        describe('deleteDraft', () => {
-            it('deletes a draft', async () => {
-                const args = { id: 'test-draft-id-1' };
-                await mutators.draft.deleteDraft.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.delete).toHaveBeenCalledWith({ id: 'test-draft-id-1' });
-            });
-        });
-        describe('scheduleSend', () => {
-            it('schedules an immediate send with undo delay', async () => {
-                const args = { id: 'test-draft-id-1', kind: 'IMMEDIATE', undoMs: 5000, updatedAt: 1000000 };
-                await mutators.draft.scheduleSend.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    id: 'test-draft-id-1',
-                    scheduledFor: 1005000,
-                    status: 'SEND_REQUESTED',
-                    updatedAt: 1000000,
-                });
-            });
-            it('schedules a future send', async () => {
-                const args = { id: 'test-draft-id-1', kind: 'SCHEDULED', scheduledFor: 2000000, updatedAt: 1000000 };
-                await mutators.draft.scheduleSend.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    id: 'test-draft-id-1',
-                    scheduledFor: 2000000,
-                    status: 'SEND_REQUESTED',
-                    updatedAt: 1000000,
-                });
-            });
-        });
-        describe('setContent', () => {
-            it('applies a content patch', async () => {
-                tx.run = mock(() => Promise.resolve({ body: { bcc: [], cc: [], content: 'test-content', to: [] } }));
-                const args = {
-                    id: 'test-draft-id-1',
-                    patch: [{ index: 12, type: 'INSERTION', value: ' test-value' }],
-                    updatedAt: 1234567890,
-                };
-                await mutators.draft.setContent.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    body: { bcc: [], cc: [], content: 'test-content test-value', to: [] },
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                });
-            });
-            it('does nothing if draft not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = { id: 'test-draft-id-1', patch: [], updatedAt: 1234567890 };
-                await mutators.draft.setContent.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).not.toHaveBeenCalled();
-            });
-        });
-        describe('setEnvelope', () => {
-            it('updates envelope fields', async () => {
-                tx.run = mock(() => Promise.resolve({ body: { content: 'test-content' } }));
-                const args = {
-                    envelope: {
-                        bcc: ['test-email-1@example.com'],
-                        cc: [],
-                        subject: 'test-subject',
-                        to: ['test-email-2@example.com'],
-                    },
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                };
-                await mutators.draft.setEnvelope.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    body: {
-                        bcc: ['test-email-1@example.com'],
-                        cc: [],
-                        content: 'test-content',
-                        to: ['test-email-2@example.com'],
-                    },
-                    id: 'test-draft-id-1',
-                    subject: 'test-subject',
-                    updatedAt: 1234567890,
-                });
-            });
-        });
-        describe('setFrom', () => {
-            it('updates from fields', async () => {
-                const args = {
-                    accountId: 'test-account-id-2',
-                    aliasId: 'test-alias-id-2',
-                    from: 'test-email-3@example.com',
-                    fromName: 'test-alias-new-name',
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                };
-                await mutators.draft.setFrom.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-2',
-                    fromAliasId: 'test-alias-id-2',
-                    fromEmail: 'test-email-3@example.com',
-                    fromName: 'test-alias-new-name',
-                    id: 'test-draft-id-1',
-                    updatedAt: 1234567890,
-                });
-            });
-        });
-    });
-    describe('thread', () => {
-        describe('addLabel', () => {
-            it('adds a label to threads', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce({ id: 'test-label-id-1', uidValidity: 1, unreadCount: 0 })
-                    .mockResolvedValueOnce({
-                    id: 'test-thread-id-1',
-                    labelIdList: ' test-label-id-2 ',
-                    latestMessageDate: 1234567890,
-                    seen: true,
-                })
-                    .mockResolvedValueOnce([{ id: 'test-message-id-1' }])
-                    .mockResolvedValueOnce(null);
-                const args = {
-                    accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
-                    labelPath: 'INBOX',
-                };
-                await mutators.thread.addLabel.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.threadByLabel.insert).toHaveBeenCalledWith({
-                    labelId: 'test-label-id-1',
-                    latestMessageDate: 1234567890,
-                    threadId: 'test-thread-id-1',
-                });
-                expect(tx.mutate.threadLabel.insert).toHaveBeenCalled();
-                expect(tx.mutate.thread.update).toHaveBeenCalledWith({
-                    id: 'test-thread-id-1',
-                    labelIdList: expect.stringContaining('test-label-id-1'),
-                });
-            });
-            it('does nothing if label not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = {
-                    accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
-                    labelPath: 'NONEXISTENT',
-                };
-                await mutators.thread.addLabel.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.thread.update).not.toHaveBeenCalled();
-                expect(tx.mutate.threadByLabel.insert).not.toHaveBeenCalled();
-            });
-        });
-        describe('delete', () => {
-            it('deletes threads and updates unread counts', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce({ id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: false })
-                    .mockResolvedValueOnce([{ id: 'test-label-id-1', unreadCount: 5 }]);
-                const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } } };
-                await mutators.thread.delete.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'test-label-id-1', unreadCount: 4 });
-                expect(tx.mutate.thread.delete).toHaveBeenCalledWith({ id: 'test-thread-id-1' });
-            });
-            it('skips unread count update for seen threads', async () => {
-                tx.run = mock(() => Promise.resolve({ id: 'test-thread-id-1', labelIdList: '', seen: true }));
-                const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } } };
-                await mutators.thread.delete.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountLabel.update).not.toHaveBeenCalled();
-                expect(tx.mutate.thread.delete).toHaveBeenCalledWith({ id: 'test-thread-id-1' });
-            });
-        });
-        describe('removeLabel', () => {
-            it('removes a label from threads', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce({ id: 'test-label-id-1', unreadCount: 5 })
-                    .mockResolvedValueOnce({
-                    id: 'test-thread-id-1',
-                    labelIdList: ' test-label-id-1 test-label-id-2 ',
-                    seen: false,
-                })
-                    .mockResolvedValueOnce([{ id: 'test-message-id-1' }]);
-                const args = {
-                    accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
-                    labelPath: 'INBOX',
-                };
-                await mutators.thread.removeLabel.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.threadLabel.delete).toHaveBeenCalledWith({
-                    accountId: 'test-account-id-1',
-                    labelId: 'test-label-id-1',
-                    threadMessageId: 'test-message-id-1',
-                });
-                expect(tx.mutate.threadByLabel.delete).toHaveBeenCalledWith({
-                    labelId: 'test-label-id-1',
-                    threadId: 'test-thread-id-1',
-                });
-                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'test-label-id-1', unreadCount: 4 });
-            });
-            it('does nothing if thread does not have label', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce({ id: 'test-label-id-1' })
-                    .mockResolvedValueOnce({ id: 'test-thread-id-1', labelIdList: ' test-label-id-2 ' })
-                    .mockResolvedValueOnce([]);
-                const args = {
-                    accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
-                    labelPath: 'INBOX',
-                };
-                await mutators.thread.removeLabel.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.threadLabel.delete).not.toHaveBeenCalled();
-                expect(tx.mutate.threadByLabel.delete).not.toHaveBeenCalled();
-            });
-        });
-        describe('setFlagged', () => {
-            it('sets flagged status', async () => {
-                const args = {
-                    accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1', 'test-thread-id-2'] } },
-                    flagged: true,
-                };
-                await mutators.thread.setFlagged.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ flagged: true, id: 'test-thread-id-1' });
-                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ flagged: true, id: 'test-thread-id-2' });
-            });
-        });
-        describe('setSeen', () => {
-            it('marks threads as seen and updates label counts', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce([{ id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: false }])
-                    .mockResolvedValueOnce([{ id: 'test-label-id-1', unreadCount: 5 }]);
-                const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } }, seen: true };
-                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'test-label-id-1', unreadCount: 4 });
-                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ id: 'test-thread-id-1', seen: true });
-            });
-            it('marks threads as unseen and increments label counts', async () => {
-                tx.run = mock()
-                    .mockResolvedValueOnce([{ id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: true }])
-                    .mockResolvedValueOnce([{ id: 'test-label-id-1', unreadCount: 5 }]);
-                const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } }, seen: false };
-                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'test-label-id-1', unreadCount: 6 });
-                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ id: 'test-thread-id-1', seen: false });
-            });
-            it('skips label update when thread seen status unchanged', async () => {
-                tx.run = mock(() => Promise.resolve([{ id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: true }]));
-                const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } }, seen: true };
-                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.accountLabel.update).not.toHaveBeenCalled();
-            });
-        });
-        const systemLabelTestCases = [
-            { mutatorName: 'setArchive', specialUse: 'ARCHIVE' },
-            { mutatorName: 'setInbox', specialUse: 'INBOX' },
-            { mutatorName: 'setSpam', specialUse: 'SPAM' },
-            { mutatorName: 'setTrash', specialUse: 'TRASH' },
-        ];
-        for (const { mutatorName, specialUse } of systemLabelTestCases) {
-            describe(mutatorName, () => {
-                it(`moves thread to ${specialUse} label`, async () => {
-                    tx.run = mock()
-                        .mockResolvedValueOnce({
-                        accountId: 'test-account-id-1',
-                        id: 'test-thread-id-1',
-                        labelIdList: ' test-label-id-1 ',
-                        latestMessageDate: 1234567890,
-                        seen: true,
-                    })
-                        .mockResolvedValueOnce({ id: 'test-label-id-2', uidValidity: 1 })
-                        .mockResolvedValueOnce([{ id: 'test-message-id-1' }])
-                        .mockResolvedValueOnce([{ id: 'test-label-id-1', unreadCount: 0 }]);
-                    const args = { accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } } };
-                    await mutators.thread[mutatorName].fn({ args, ctx, tx: tx });
-                    expect(tx.mutate.threadByLabel.delete).toHaveBeenCalledWith({
-                        labelId: 'test-label-id-1',
-                        threadId: 'test-thread-id-1',
-                    });
-                    expect(tx.mutate.threadByLabel.insert).toHaveBeenCalledWith({
-                        labelId: 'test-label-id-2',
-                        latestMessageDate: 1234567890,
-                        threadId: 'test-thread-id-1',
-                    });
-                    expect(tx.mutate.thread.update).toHaveBeenCalledWith({
-                        id: 'test-thread-id-1',
-                        labelIdList: expect.stringContaining('test-label-id-2'),
-                    });
-                });
-            });
-        }
-    });
-    describe('user', () => {
-        describe('deleteSettingsPushNotificationToken', () => {
-            it('deletes a push notification token', async () => {
-                const args = { id: 'test-token-id-1', token: 'test-token-1' };
-                await mutators.user.deleteSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.userPushNotificationToken.delete).toHaveBeenCalledWith({ id: 'test-token-id-1' });
-            });
-        });
-        describe('setSettingsName', () => {
-            it('updates user name', async () => {
-                const args = { id: 'test-user-id-1', name: 'test-user-new-name' };
-                await mutators.user.setSettingsName.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({ id: 'test-user-id-1', name: 'test-user-new-name' });
-            });
-        });
-        describe('setSettingsPushNotificationToken', () => {
-            it('inserts a new push notification token', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = {
-                    id: 'test-user-id-1',
-                    pushNotificationToken: { createdAt: 1234567890, id: 'test-token-id-1', token: 'test-token-1' },
-                };
-                await mutators.user.setSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.userPushNotificationToken.insert).toHaveBeenCalledWith({
-                    createdAt: 1234567890,
-                    id: 'test-token-id-1',
-                    token: 'test-token-1',
-                    userId: 'test-user-id-1',
-                });
-            });
-            it('skips insert if token already exists', async () => {
-                tx.run = mock(() => Promise.resolve({ id: 'existing-token' }));
-                const args = {
-                    id: 'test-user-id-1',
-                    pushNotificationToken: { createdAt: 1234567890, id: 'test-token-id-1', token: 'test-token-1' },
-                };
-                await mutators.user.setSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.userPushNotificationToken.insert).not.toHaveBeenCalled();
-            });
-        });
-        describe('createView', () => {
-            it('creates a new view', async () => {
-                tx.run = mock(() => Promise.resolve({ id: 'test-user-id-1', views: [] }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                });
-            });
-            it('deduplicates aliasEmails', async () => {
-                tx.run = mock(() => Promise.resolve({ id: 'test-user-id-1', views: [] }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com', 'test-email-1@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                });
-            });
-            it('appends to existing views', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-2',
-                        name: 'test-view-name-2',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                        {
-                            aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-2',
-                            name: 'test-view-name-2',
-                        },
-                    ],
-                });
-            });
-            it('does nothing if user not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-            it('does nothing if view with same id already exists', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-2',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-            it('does nothing if max views limit reached', async () => {
-                const existingViews = Array.from({ length: 25 }, (_, i) => ({
-                    aliasEmails: [`test-email-${i}@example.com`, `test-email-${i}b@example.com`],
-                    icon: CustomViewIcon.STAR,
-                    id: `test-view-id-${i}`,
-                    name: `test-view-name-${i}`,
-                }));
-                tx.run = mock(() => Promise.resolve({ id: 'test-user-id-1', views: existingViews }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.createView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-        });
-        describe('deleteView', () => {
-            it('deletes a view', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                        {
-                            aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-2',
-                            name: 'test-view-name-2',
-                        },
-                    ],
-                }));
-                const args = { id: 'test-user-id-1', viewId: 'test-view-id-1' };
-                await mutators.user.deleteView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-2',
-                            name: 'test-view-name-2',
-                        },
-                    ],
-                });
-            });
-            it('does nothing if user not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = { id: 'test-user-id-1', viewId: 'test-view-id-1' };
-                await mutators.user.deleteView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-        });
-        describe('updateView', () => {
-            it('updates view name', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-updated-name',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-updated-name',
-                        },
-                    ],
-                });
-            });
-            it('updates view aliasEmails', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                });
-            });
-            it('deduplicates aliasEmails on update', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com', 'test-email-1@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-2@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                });
-            });
-            it('updates view icon', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.HEART,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.HEART,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                });
-            });
-            it('updates both name and aliasEmails', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-updated-name',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-updated-name',
-                        },
-                    ],
-                });
-            });
-            it('does nothing if user not found', async () => {
-                tx.run = mock(() => Promise.resolve(null));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-updated-name',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-            it('does nothing if view does not exist', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-nonexistent',
-                        name: 'test-updated-name',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).not.toHaveBeenCalled();
-            });
-            it('leaves non-matching views unchanged', async () => {
-                tx.run = mock(() => Promise.resolve({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                        {
-                            aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-2',
-                            name: 'test-view-name-2',
-                        },
-                    ],
-                }));
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-updated-name',
-                    },
-                };
-                await mutators.user.updateView.fn({ args, ctx, tx: tx });
-                expect(tx.mutate.user.update).toHaveBeenCalledWith({
-                    id: 'test-user-id-1',
-                    views: [
-                        {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-1',
-                            name: 'test-view-updated-name',
-                        },
-                        {
-                            aliasEmails: ['test-email-2@example.com', 'test-email-2b@example.com'],
-                            icon: CustomViewIcon.STAR,
-                            id: 'test-view-id-2',
-                            name: 'test-view-name-2',
-                        },
-                    ],
-                });
-            });
-            it('schema rejects empty aliasEmails array', () => {
-                const args = {
-                    id: 'test-user-id-1',
-                    view: { aliasEmails: [], icon: CustomViewIcon.STAR, id: 'test-view-id-1', name: 'test-view-name-1' },
-                };
-                const result = v.safeParse(mutatorSchemas.user.updateView, args);
-                expect(result.success).toBe(false);
-            });
-            it('schema rejects aliasEmails array with only 1 email', () => {
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com'],
-                        icon: CustomViewIcon.STAR,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                const result = v.safeParse(mutatorSchemas.user.updateView, args);
-                expect(result.success).toBe(false);
-            });
-            for (const icon of USER_SETTINGS_CUSTOM_VIEW_ICONS) {
-                it(`schema accepts valid icon value: ${icon}`, () => {
-                    const args = {
-                        id: 'test-user-id-1',
-                        view: {
-                            aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                            icon,
-                            id: 'test-view-id-1',
-                            name: 'test-view-name-1',
-                        },
-                    };
-                    const result = v.safeParse(mutatorSchemas.user.updateView, args);
-                    expect(result.success).toBe(true);
-                });
-            }
-            it('schema rejects null icon value', () => {
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: null,
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                const result = v.safeParse(mutatorSchemas.user.updateView, args);
-                expect(result.success).toBe(false);
-            });
-            it('schema rejects invalid icon value', () => {
-                const args = {
-                    id: 'test-user-id-1',
-                    view: {
-                        aliasEmails: ['test-email-1@example.com', 'test-email-1b@example.com'],
-                        icon: 'INVALID_ICON',
-                        id: 'test-view-id-1',
-                        name: 'test-view-name-1',
-                    },
-                };
-                const result = v.safeParse(mutatorSchemas.user.updateView, args);
-                expect(result.success).toBe(false);
-            });
-        });
-    });
-});