@marcoappio/marco-config 2.0.490 → 2.0.492

package/dist/zero/mutators/accountMutators/accountMutators.js

@@ -1,5 +1,5 @@
 import { MutationError } from '../../../types';
-export const createAccountMutators = (authData, callbacks) => ({
+export const createAccountMutators = (authData) => ({
     createAccount: async (tx, args) => {
         if (!authData) {
             throw new Error(MutationError.AUTHENTICATION_REQUIRED);
@@ -21,7 +21,6 @@ export const createAccountMutators = (authData, callbacks) => ({
             isPrimary: true,
             name: null,
         });
-        callbacks?.createAccount?.(args);
     },
     createAlias: async (tx, args) => {
         await tx.mutate.accountAlias.insert({
@@ -31,13 +30,11 @@ export const createAccountMutators = (authData, callbacks) => ({
             isPrimary: false,
             name: args.alias.name ?? null,
         });
-        callbacks?.createAlias?.(args);
     },
     deleteAccount: async (tx, args) => {
         await tx.mutate.account.delete({
             id: args.id,
         });
-        callbacks?.deleteAccount?.(args);
     },
     deleteAlias: async (tx, args) => {
         const alias = await tx.query.accountAlias.where('id', args.aliasId).one().run();
@@ -64,14 +61,12 @@ export const createAccountMutators = (authData, callbacks) => ({
                 });
             }
         }
-        callbacks?.deleteAlias?.(args);
     },
     setAliasName: async (tx, args) => {
         await tx.mutate.accountAlias.update({
             id: args.aliasId,
             name: args.displayName,
         });
-        callbacks?.setAliasName?.(args);
     },
     setAliasPrimary: async (tx, args) => {
         const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
@@ -85,21 +80,18 @@ export const createAccountMutators = (authData, callbacks) => ({
             id: args.accountId,
             primaryAliasId: args.aliasId,
         });
-        callbacks?.setAliasPrimary?.(args);
     },
     setConnectionConfigImapRaw: async (tx, args) => {
         await tx.mutate.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
         });
-        callbacks?.setConnectionConfigImapRaw?.(args);
     },
     setConnectionConfigOauth: async (tx, args) => {
         await tx.mutate.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
         });
-        callbacks?.setConnectionConfigOauth?.(args);
     },
     setSettings: async (tx, args) => {
         await tx.mutate.account.update({
@@ -107,6 +99,5 @@ export const createAccountMutators = (authData, callbacks) => ({
             displayName: args.displayName ? args.displayName : undefined,
             id: args.id,
         });
-        callbacks?.setSettings?.(args);
     },
 });

package/dist/zero/mutators/accountMutators/accountMutators.test.js

@@ -2,15 +2,10 @@ import { describe, expect, it, mock } from 'bun:test';
 import { createMutators, ZeroMutatorValidationError } from '../mutators';
 describe('accountMutators', () => {
     describe('createAccount', () => {
-        it('creates an account and invokes the callback', async () => {
+        it('creates an account', async () => {
             const accountInsert = mock(async () => { });
             const accountAliasInsert = mock(async () => { });
-            const createAccountCallback = mock(() => { });
-            const mutators = createMutators({ sub: 'test-user-id' }, {
-                account: {
-                    createAccount: createAccountCallback,
-                },
-            });
+            const mutators = createMutators({ sub: 'test-user-id' });
             const payload = {
                 aliasId: 'test-alias-id-1',
                 color: '#ff0000',
@@ -50,7 +45,6 @@ describe('accountMutators', () => {
                 isPrimary: true,
                 name: null,
             });
-            expect(createAccountCallback).toHaveBeenCalledWith(payload);
             expect(accountInsert.mock.invocationCallOrder[0]).toBeLessThan(accountAliasInsert.mock.invocationCallOrder[0]);
         });
         it('throws ZeroMutatorValidationError on invalid payloads', async () => {
@@ -69,12 +63,7 @@ describe('accountMutators', () => {
     describe('createAlias', () => {
         it('creates an alias', async () => {
             const accountAliasInsert = mock(async () => { });
-            const createAliasCallback = mock(() => { });
-            const mutators = createMutators({ sub: 'test-user-id' }, {
-                account: {
-                    createAlias: createAliasCallback,
-                },
-            });
+            const mutators = createMutators({ sub: 'test-user-id' });
             const transaction = {
                 mutate: {
                     accountAlias: {
@@ -100,18 +89,12 @@ describe('accountMutators', () => {
                 isPrimary: false,
                 name: 'Work Email',
             });
-            expect(createAliasCallback).toHaveBeenCalled();
         });
     });
     describe('deleteAccount', () => {
         it('deletes an account', async () => {
             const accountDelete = mock(async () => { });
-            const deleteAccountCallback = mock(() => { });
-            const mutators = createMutators({ sub: 'test-user-id' }, {
-                account: {
-                    deleteAccount: deleteAccountCallback,
-                },
-            });
+            const mutators = createMutators({ sub: 'test-user-id' });
             const transaction = {
                 mutate: {
                     account: {
@@ -128,7 +111,6 @@ describe('accountMutators', () => {
             expect(accountDelete).toHaveBeenCalledWith({
                 id: 'test-account-id-1',
             });
-            expect(deleteAccountCallback).toHaveBeenCalled();
         });
     });
     describe('deleteAlias', () => {

package/dist/zero/mutators/draftMutators/draftMutators.d.ts

@@ -1,8 +1,4 @@
-import type * as v from 'valibot';
 import { type AuthData, type HandlerMap } from '../../../types';
 import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-export type DraftMutatorCallbacks = {
-    [K in keyof ZeroMutatorSchemas['draft']]?: (args: v.InferOutput<ZeroMutatorSchemas['draft'][K]['delta']>) => Promise<void>;
-};
-export declare const createDraftMutators: (authData: AuthData | undefined, callbacks?: DraftMutatorCallbacks) => HandlerMap<ZeroMutatorSchemas["draft"]>;
+export declare const createDraftMutators: (authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["draft"]>;
 //# sourceMappingURL=draftMutators.d.ts.map

package/dist/zero/mutators/draftMutators/draftMutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CACzC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KACzD,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,GAAG,SAAS,cAClB,qBAAqB,KAChC,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CA2KvC,CAAA"}
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,mBAAmB,aAAc,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAwJzG,CAAA"}

package/dist/zero/mutators/draftMutators/draftMutators.js

@@ -1,6 +1,6 @@
 import { MutationError } from '../../../types';
 import { stringPatch } from '../../../utils';
-export const createDraftMutators = (authData, callbacks) => ({
+export const createDraftMutators = (authData) => ({
     cancelSend: async (tx, args) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
@@ -15,7 +15,6 @@ export const createDraftMutators = (authData, callbacks) => ({
             status: 'DRAFT',
             updatedAt: args.updatedAt,
         });
-        callbacks?.cancelSend?.(args);
     },
     createAttachment: async (tx, args) => {
         await tx.mutate.draftAttachment.insert({
@@ -30,7 +29,6 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        callbacks?.createAttachment?.(args);
     },
     createDraft: async (tx, args) => {
         if (!authData) {
@@ -67,7 +65,6 @@ export const createDraftMutators = (authData, callbacks) => ({
                 totalSize: attachment.totalSize,
             });
         }
-        callbacks?.createDraft?.(args);
     },
     deleteAttachment: async (tx, args) => {
         await tx.mutate.draftAttachment.delete({
@@ -77,13 +74,11 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        callbacks?.deleteAttachment?.(args);
     },
     deleteDraft: async (tx, args) => {
         await tx.mutate.draft.delete({
             id: args.id,
         });
-        callbacks?.deleteDraft?.(args);
     },
     scheduleSend: async (tx, args) => {
         if (args.kind === 'IMMEDIATE') {
@@ -102,24 +97,20 @@ export const createDraftMutators = (authData, callbacks) => ({
                 updatedAt: args.updatedAt,
             });
         }
-        callbacks?.scheduleSend?.(args);
     },
     setContent: async (tx, args) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
-        const currentContent = typeof draft.body?.content === 'string' ? draft.body.content : '';
-        const updatedBody = {
-            ...draft.body,
-            content: stringPatch.apply(currentContent, args.patch),
-        };
         await tx.mutate.draft.update({
-            body: updatedBody,
+            body: {
+                ...draft.body,
+                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', args.patch),
+            },
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        callbacks?.setContent?.(args);
     },
     setEnvelope: async (tx, args) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
@@ -137,7 +128,6 @@ export const createDraftMutators = (authData, callbacks) => ({
             subject: args.envelope.subject,
             updatedAt: args.updatedAt,
         });
-        callbacks?.setEnvelope?.(args);
     },
     setFrom: async (tx, args) => {
         await tx.mutate.draft.update({
@@ -148,6 +138,5 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        callbacks?.setFrom?.(args);
     },
 });

package/dist/zero/mutators/mutators.d.ts

@@ -1,15 +1,8 @@
 import * as v from 'valibot';
 import type { MutatorMap } from '../../types';
 import { type ZeroMutatorSchemas } from '../../zero/mutatorSchemas';
-import { type AccountMutatorCallbacks } from './accountMutators';
-import { type DraftMutatorCallbacks } from './draftMutators';
-import { type ThreadMutatorCallbacks } from './threadMutators';
-import { type UserMutatorCallbacks } from './userMutators';
-export type MutatorCallbacks = {
-    account?: AccountMutatorCallbacks;
-    draft?: DraftMutatorCallbacks;
-    thread?: ThreadMutatorCallbacks;
-    user?: UserMutatorCallbacks;
+export type AuthData = {
+    sub: string;
 };
 export declare class ZeroMutatorValidationError extends Error {
     readonly issues: ReturnType<typeof v.flatten>;
@@ -21,9 +14,5 @@ export type MarcoZeroMutators = {
     thread: MutatorMap<ZeroMutatorSchemas['thread']>;
     user: MutatorMap<ZeroMutatorSchemas['user']>;
 };
-export declare const createMutators: (authData?: AuthData, callbacks?: MutatorCallbacks) => MarcoZeroMutators;
-export type { AccountMutatorCallbacks, DraftMutatorCallbacks, ThreadMutatorCallbacks, UserMutatorCallbacks };
-export type AuthData = {
-    sub: string;
-};
+export declare const createMutators: (authData?: AuthData) => MarcoZeroMutators;
 //# sourceMappingURL=mutators.d.ts.map

package/dist/zero/mutators/mutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAkD,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrG,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,mCAAmC,CAAA;AAG/F,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,mBAAmB,CAAA;AACvF,OAAO,EAAuB,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AACjF,OAAO,EAAwB,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAE9E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,uBAAuB,CAAA;IACjC,KAAK,CAAC,EAAE,qBAAqB,CAAA;IAC7B,MAAM,CAAC,EAAE,sBAAsB,CAAA;IAC/B,IAAI,CAAC,EAAE,oBAAoB,CAAA;CAC5B,CAAA;AA8BD,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;gBAApC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;CAG1D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAA;IAClD,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,cAAc,cAAe,QAAQ,cAAc,gBAAgB,KAAG,iBAKjF,CAAA;AAEF,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAA;AAC5G,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA"}
+{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAkD,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrG,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,mCAAmC,CAAA;AAQ/F,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AA8BD,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;gBAApC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;CAG1D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAA;IAClD,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,cAAc,cAAe,QAAQ,KAAG,iBAKnD,CAAA"}

package/dist/zero/mutators/mutators.js

@@ -31,9 +31,9 @@ export class ZeroMutatorValidationError extends Error {
         this.issues = issues;
     }
 }
-export const createMutators = (authData, callbacks) => ({
-    account: buildMutatorMap(zeroMutatorSchemas.account, createAccountMutators(authData, callbacks?.account)),
-    draft: buildMutatorMap(zeroMutatorSchemas.draft, createDraftMutators(authData, callbacks?.draft)),
-    thread: buildMutatorMap(zeroMutatorSchemas.thread, createThreadMutators(authData, callbacks?.thread)),
-    user: buildMutatorMap(zeroMutatorSchemas.user, createUserMutators(authData, callbacks?.user)),
+export const createMutators = (authData) => ({
+    account: buildMutatorMap(zeroMutatorSchemas.account, createAccountMutators(authData)),
+    draft: buildMutatorMap(zeroMutatorSchemas.draft, createDraftMutators(authData)),
+    thread: buildMutatorMap(zeroMutatorSchemas.thread, createThreadMutators(authData)),
+    user: buildMutatorMap(zeroMutatorSchemas.user, createUserMutators(authData)),
 });

package/dist/zero/mutators/threadMutators/threadMutators.d.ts

@@ -1,12 +1,8 @@
 import type { Transaction } from '@rocicorp/zero';
-import type * as v from 'valibot';
 import type { LabelSpecialUse } from '../../../types';
 import { type AuthData, type HandlerMap } from '../../../types';
 import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
 import type { MarcoZeroSchema } from '../../../zero/schema';
-export type ThreadMutatorCallbacks = {
-    [K in keyof ZeroMutatorSchemas['thread']]?: (args: v.InferOutput<ZeroMutatorSchemas['thread'][K]['delta']>) => Promise<void>;
-};
 export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
-export declare const createThreadMutators: (_authData: AuthData | undefined, callbacks?: ThreadMutatorCallbacks) => HandlerMap<ZeroMutatorSchemas["thread"]>;
+export declare const createThreadMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["thread"]>;
 //# sourceMappingURL=threadMutators.d.ts.map

package/dist/zero/mutators/threadMutators/threadMutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEhE,MAAM,MAAM,sBAAsB,GAAG;KAClC,CAAC,IAAI,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAC1C,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAC1D,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAKD,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA6OxC,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAIhE,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,oBAAoB,cAAe,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA0O5G,CAAA"}

package/dist/zero/mutators/threadMutators/threadMutators.js

@@ -1,6 +1,6 @@
 import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
-const buildLabelIdList = (labelIds) => labelIds.length === 0 ? '' : ` ${[...new Set(labelIds)].join(' ')} `;
+const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const thread = await tx.query.thread.where('id', threadId).one().run();
     if (!thread) {
@@ -70,146 +70,153 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
         labelIdList: buildLabelIdList([targetLabel.id]),
     });
 };
-export const createThreadMutators = (_authData, callbacks) => ({
+export const createThreadMutators = (_authData) => ({
     addLabel: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const [label, messages] = await Promise.all([
-                tx.query.accountLabel.where('accountId', thread.accountId).where('path', args.labelPath).one().run(),
-                tx.query.threadMessage.where('threadId', threadId).run(),
-            ]);
+        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
-            const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-            if (!currentLabelIds.has(label.id)) {
-                await Promise.all([
-                    tx.mutate.threadByLabel.insert({
+            for (const threadId of threadIds) {
+                const [thread, messages] = await Promise.all([
+                    tx.query.thread.where('id', threadId).one().run(),
+                    tx.query.threadMessage.where('threadId', threadId).run(),
+                ]);
+                if (!thread) {
+                    throw new Error(MutationError.ENTITY_NOT_FOUND);
+                }
+                const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
+                if (!currentLabelIds.has(label.id)) {
+                    await Promise.all([
+                        tx.mutate.threadByLabel.insert({
+                            labelId: label.id,
+                            latestMessageDate: thread.latestMessageDate,
+                            threadId,
+                        }),
+                        ...(thread.seen === false
+                            ? [
+                                tx.mutate.accountLabel.update({
+                                    id: label.id,
+                                    unreadCount: (label.unreadCount ?? 0) + 1,
+                                }),
+                            ]
+                            : []),
+                    ]);
+                }
+                const existingChecks = await Promise.all(messages.map(x => tx.query.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one().run()));
+                const messagesToInsert = messages.filter((_, i) => !existingChecks[i]);
+                const baseTimestamp = Date.now();
+                if (messagesToInsert.length > 0) {
+                    await Promise.all(messagesToInsert.map((x, i) => tx.mutate.threadLabel.insert({
+                        accountId,
                         labelId: label.id,
-                        latestMessageDate: thread.latestMessageDate,
+                        lastSyncedAt: 0,
                         threadId,
-                    }),
-                    ...(thread.seen === false
-                        ? [
-                            tx.mutate.accountLabel.update({
-                                id: label.id,
-                                unreadCount: (label.unreadCount ?? 0) + 1,
-                            }),
-                        ]
-                        : []),
-                ]);
-            }
-            const existingChecks = await Promise.all(messages.map(message => tx.query.threadLabel.where('threadMessageId', message.id).where('labelId', label.id).one().run()));
-            const messagesToInsert = messages.filter((_, i) => !existingChecks[i]);
-            const baseTimestamp = Date.now();
-            if (messagesToInsert.length > 0) {
-                await Promise.all(messagesToInsert.map((message, i) => tx.mutate.threadLabel.insert({
-                    accountId: thread.accountId,
-                    labelId: label.id,
-                    lastSyncedAt: 0,
-                    threadId,
-                    threadMessageId: message.id,
-                    uid: -(baseTimestamp + i),
-                    uidValidity: label.uidValidity ?? 0,
-                })));
+                        threadMessageId: x.id,
+                        uid: -(baseTimestamp + i),
+                        uidValidity: label.uidValidity ?? 0,
+                    })));
+                }
+                currentLabelIds.add(label.id);
+                await tx.mutate.thread.update({
+                    id: threadId,
+                    labelIdList: buildLabelIdList([...currentLabelIds]),
+                });
             }
-            currentLabelIds.add(label.id);
-            await tx.mutate.thread.update({
-                id: threadId,
-                labelIdList: buildLabelIdList([...currentLabelIds]),
-            });
         }
-        callbacks?.addLabel?.(args);
     },
     delete: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (thread) {
-                if (thread.seen === false) {
-                    const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
-                    if (labelIds.length > 0) {
-                        const labels = await tx.query.accountLabel.where('id', 'IN', labelIds).run();
-                        await Promise.all(labels.map(label => tx.mutate.accountLabel.update({
-                            id: label.id,
-                            unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-                        })));
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            for (const threadId of threadIds) {
+                const thread = await tx.query.thread.where('id', threadId).one().run();
+                if (thread) {
+                    if (thread.seen === false) {
+                        const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
+                        if (labelIds.length > 0) {
+                            const labels = await tx.query.accountLabel.where('id', 'IN', labelIds).run();
+                            await Promise.all(labels.map(x => tx.mutate.accountLabel.update({
+                                id: x.id,
+                                unreadCount: Math.max(0, (x.unreadCount ?? 0) - 1),
+                            })));
+                        }
                     }
+                    await tx.mutate.thread.delete({
+                        id: threadId,
+                    });
                 }
-                await tx.mutate.thread.delete({
-                    id: threadId,
-                });
             }
         }
-        callbacks?.delete?.(args);
     },
     removeLabel: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const [label, messages] = await Promise.all([
-                tx.query.accountLabel.where('accountId', thread.accountId).where('path', args.labelPath).one().run(),
-                tx.query.threadMessage.where('threadId', threadId).run(),
-            ]);
+        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
-            const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-            if (!currentLabelIds.has(label.id)) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
+            for (const threadId of threadIds) {
+                const [thread, messages] = await Promise.all([
+                    tx.query.thread.where('id', threadId).one().run(),
+                    tx.query.threadMessage.where('threadId', threadId).run(),
+                ]);
+                if (!thread) {
+                    throw new Error(MutationError.ENTITY_NOT_FOUND);
+                }
+                const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
+                if (!currentLabelIds.has(label.id)) {
+                    throw new Error(MutationError.ENTITY_NOT_FOUND);
+                }
+                currentLabelIds.delete(label.id);
+                await Promise.all([
+                    ...messages.map(x => tx.mutate.threadLabel.delete({
+                        accountId,
+                        labelId: label.id,
+                        threadMessageId: x.id,
+                    })),
+                    tx.mutate.threadByLabel.delete({
+                        labelId: label.id,
+                        threadId,
+                    }),
+                    ...(thread.seen === false
+                        ? [
+                            tx.mutate.accountLabel.update({
+                                id: label.id,
+                                unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
+                            }),
+                        ]
+                        : []),
+                    tx.mutate.thread.update({
+                        id: threadId,
+                        labelIdList: buildLabelIdList([...currentLabelIds]),
+                    }),
+                ]);
             }
-            currentLabelIds.delete(label.id);
-            await Promise.all([
-                ...messages.map(message => tx.mutate.threadLabel.delete({
-                    accountId: thread.accountId,
-                    labelId: label.id,
-                    threadMessageId: message.id,
-                })),
-                tx.mutate.threadByLabel.delete({
-                    labelId: label.id,
-                    threadId,
-                }),
-                ...(thread.seen === false
-                    ? [
-                        tx.mutate.accountLabel.update({
-                            id: label.id,
-                            unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-                        }),
-                    ]
-                    : []),
-                tx.mutate.thread.update({
-                    id: threadId,
-                    labelIdList: buildLabelIdList([...currentLabelIds]),
-                }),
-            ]);
         }
-        callbacks?.removeLabel?.(args);
     },
     setArchive: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            await setSystemLabel(tx, threadId, 'ARCHIVE');
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            for (const threadId of threadIds) {
+                await setSystemLabel(tx, threadId, 'ARCHIVE');
+            }
         }
-        callbacks?.setArchive?.(args);
     },
     setFlagged: async (tx, args) => {
-        await Promise.all(args.threadIds.map(threadId => tx.mutate.thread.update({
-            flagged: args.flagged,
-            id: threadId,
-        })));
-        callbacks?.setFlagged?.(args);
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            await Promise.all(threadIds.map(threadId => tx.mutate.thread.update({
+                flagged: args.flagged,
+                id: threadId,
+            })));
+        }
     },
     setInbox: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            await setSystemLabel(tx, threadId, 'INBOX');
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            for (const threadId of threadIds) {
+                await setSystemLabel(tx, threadId, 'INBOX');
+            }
         }
-        callbacks?.setInbox?.(args);
     },
     setSeen: async (tx, args) => {
-        const threads = await tx.query.thread.where('id', 'IN', args.threadIds).run();
+        const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
+        const threads = await tx.query.thread.where('id', 'IN', allThreadIds).run();
         const labelCounts = new Map();
         for (const thread of threads) {
             if (thread.seen !== args.seen) {
@@ -222,28 +229,29 @@ export const createThreadMutators = (_authData, callbacks) => ({
             const labels = await tx.query.accountLabel.where('id', 'IN', [...labelCounts.keys()]).run();
             const delta = args.seen ? -1 : 1;
             await Promise.all(labels
-                .filter(label => labelCounts.has(label.id))
-                .map(label => tx.mutate.accountLabel.update({
-                id: label.id,
-                unreadCount: Math.max(0, (label.unreadCount ?? 0) + delta * (labelCounts.get(label.id) ?? 0)),
+                .filter(x => labelCounts.has(x.id))
+                .map(x => tx.mutate.accountLabel.update({
+                id: x.id,
+                unreadCount: Math.max(0, (x.unreadCount ?? 0) + delta * (labelCounts.get(x.id) ?? 0)),
             })));
         }
-        await Promise.all(args.threadIds.map(threadId => tx.mutate.thread.update({
+        await Promise.all(allThreadIds.map(threadId => tx.mutate.thread.update({
             id: threadId,
             seen: args.seen,
         })));
-        callbacks?.setSeen?.(args);
     },
     setSpam: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            await setSystemLabel(tx, threadId, 'SPAM');
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            for (const threadId of threadIds) {
+                await setSystemLabel(tx, threadId, 'SPAM');
+            }
         }
-        callbacks?.setSpam?.(args);
     },
     setTrash: async (tx, args) => {
-        for (const threadId of args.threadIds) {
-            await setSystemLabel(tx, threadId, 'TRASH');
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            for (const threadId of threadIds) {
+                await setSystemLabel(tx, threadId, 'TRASH');
+            }
         }
-        callbacks?.setTrash?.(args);
     },
 });