@marcoappio/marco-config 2.0.508 → 2.0.510

package/dist/zero/{queries/getThreads.d.ts.map → mutators.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"getThreads.d.ts","sourceRoot":"","sources":["../../../src/zero/queries/getThreads.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAOlE,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,EAAE,CAAC,EAAE,MAAM,CAAA;QACX,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;QACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;QACvB,IAAI,CAAC,EAAE,OAAO,CAAA;KACf,CAAA;CACF,CAAA;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDtB,CAAA"}
+{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../src/zero/mutators.ts"],"names":[],"mappings":"AAWA,KAAK,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAqJjC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAysBnB,CAAA"}

package/dist/zero/mutators.js

@@ -0,0 +1,659 @@
+import { createBuilder, defineMutators, defineMutatorWithType } from '@rocicorp/zero';
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, MutationError } from '../types';
+import { stringPatch } from '../utils';
+import { threadsUtils } from '../utils/threads';
+import { schema } from './schema';
+const zql = createBuilder(schema);
+const defineMutator = defineMutatorWithType();
+const accountAliasSchema = v.object({
+    emailAddress: marcoSchemas.string.email(),
+    id: marcoSchemas.string.required(),
+    name: marcoSchemas.string.nullable(),
+});
+const accountsSchema = v.record(marcoSchemas.string.required(), v.object({
+    threadIds: v.array(marcoSchemas.string.required()),
+}));
+const baseThreadSchema = v.object({
+    accounts: accountsSchema,
+});
+const threadChangeLabelSchema = v.object({
+    accounts: accountsSchema,
+    labelPath: marcoSchemas.string.required(),
+});
+const draftBodySchema = v.object({
+    bcc: v.array(marcoSchemas.string.email()),
+    cc: v.array(marcoSchemas.string.email()),
+    content: v.pipe(v.string(), v.maxLength(384000)),
+    subject: marcoSchemas.string.nullable(),
+    to: v.array(marcoSchemas.string.email()),
+});
+const draftAttachmentSchema = v.object({
+    fileName: marcoSchemas.string.required(),
+    id: marcoSchemas.string.required(),
+    mimeType: marcoSchemas.string.required(),
+    status: v.picklist(DRAFT_ATTACHMENT_UPLOAD_STATUSES),
+    totalSize: marcoSchemas.number.positiveInteger(),
+});
+const userPushNotificationTokenSchema = v.object({
+    createdAt: marcoSchemas.number.positiveInteger(),
+    id: marcoSchemas.string.required(),
+    token: marcoSchemas.string.required(),
+});
+const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
+const setSystemLabel = async (tx, builder, threadId, targetSpecialUse) => {
+    const thread = await tx.run(builder.thread.where('id', threadId).one());
+    if (!thread) {
+        throw new Error(MutationError.ENTITY_NOT_FOUND);
+    }
+    const [targetLabel, messages] = await Promise.all([
+        tx.run(builder.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one()),
+        tx.run(builder.threadMessage.where('threadId', threadId)),
+    ]);
+    if (!targetLabel) {
+        throw new Error(MutationError.ENTITY_NOT_FOUND);
+    }
+    const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
+    const hasTarget = currentLabelIds.has(targetLabel.id);
+    const labelIdsToRemove = new Set(currentLabelIds);
+    labelIdsToRemove.delete(targetLabel.id);
+    const threadLabelDeletes = [];
+    for (const message of messages) {
+        for (const labelId of labelIdsToRemove) {
+            threadLabelDeletes.push(tx.mutate.threadLabel.delete({
+                accountId: thread.accountId,
+                labelId,
+                threadMessageId: message.id,
+            }));
+        }
+    }
+    await Promise.all([
+        ...threadLabelDeletes,
+        ...[...labelIdsToRemove].map(labelId => tx.mutate.threadByLabel.delete({ labelId, threadId })),
+    ]);
+    if (thread.seen === false && labelIdsToRemove.size > 0) {
+        const labelsToUpdate = await tx.run(builder.accountLabel.where('id', 'IN', [...labelIdsToRemove]));
+        await Promise.all(labelsToUpdate.map(label => tx.mutate.accountLabel.update({
+            id: label.id,
+            unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
+        })));
+    }
+    if (!hasTarget) {
+        const baseTimestamp = Date.now();
+        await Promise.all([
+            ...messages.map((message, i) => tx.mutate.threadLabel.insert({
+                accountId: thread.accountId,
+                labelId: targetLabel.id,
+                lastSyncedAt: 0,
+                threadId,
+                threadMessageId: message.id,
+                uid: -(baseTimestamp + i),
+                uidValidity: targetLabel.uidValidity ?? 0,
+            })),
+            tx.mutate.threadByLabel.insert({
+                labelId: targetLabel.id,
+                latestMessageDate: thread.latestMessageDate,
+                threadId,
+            }),
+            ...(thread.seen === false
+                ? [
+                    tx.mutate.accountLabel.update({
+                        id: targetLabel.id,
+                        unreadCount: (targetLabel.unreadCount ?? 0) + 1,
+                    }),
+                ]
+                : []),
+        ]);
+    }
+    await tx.mutate.thread.update({
+        id: threadId,
+        labelIdList: buildLabelIdList([targetLabel.id]),
+    });
+};
+export const mutators = defineMutators({
+    account: {
+        createAccount: defineMutator(v.object({
+            aliasId: marcoSchemas.string.required(),
+            color: marcoSchemas.string.required(),
+            emailAddress: marcoSchemas.string.email(),
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, ctx, args }) => {
+            await tx.mutate.account.insert({
+                color: args.color,
+                displayName: null,
+                id: args.id,
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+                mailProcessedCount: 0,
+                mailTotalCount: 0,
+                primaryAliasId: args.aliasId,
+                userId: ctx.userId,
+            });
+            await tx.mutate.accountAlias.insert({
+                accountId: args.id,
+                emailAddress: args.emailAddress,
+                id: args.aliasId,
+                isPrimary: true,
+                name: null,
+            });
+        }),
+        createAlias: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            alias: accountAliasSchema,
+        }), async ({ tx, args }) => {
+            await tx.mutate.accountAlias.insert({
+                accountId: args.accountId,
+                emailAddress: args.alias.emailAddress,
+                id: args.alias.id,
+                isPrimary: false,
+                name: args.alias.name ?? null,
+            });
+        }),
+        deleteAccount: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.account.delete({
+                id: args.id,
+            });
+        }),
+        deleteAlias: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            aliasId: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            const alias = await tx.run(zql.accountAlias.where('id', args.aliasId).one());
+            await tx.mutate.accountAlias.delete({
+                id: args.aliasId,
+            });
+            if (alias?.isPrimary) {
+                const remainingAliases = await tx.run(zql.accountAlias.where('accountId', args.accountId));
+                if (remainingAliases.length > 0) {
+                    const newPrimaryAlias = remainingAliases[0];
+                    await tx.mutate.accountAlias.update({
+                        id: newPrimaryAlias.id,
+                        isPrimary: true,
+                    });
+                    await tx.mutate.account.update({
+                        id: args.accountId,
+                        primaryAliasId: newPrimaryAlias.id,
+                    });
+                }
+                else {
+                    await tx.mutate.account.update({
+                        id: args.accountId,
+                        primaryAliasId: null,
+                    });
+                }
+            }
+        }),
+        setAliasName: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            aliasId: marcoSchemas.string.required(),
+            displayName: marcoSchemas.string.nullable(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.accountAlias.update({
+                id: args.aliasId,
+                name: args.displayName,
+            });
+        }),
+        setAliasPrimary: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            aliasId: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            const aliases = await tx.run(zql.accountAlias.where('accountId', args.accountId));
+            for (const alias of aliases) {
+                await tx.mutate.accountAlias.update({
+                    id: alias.id,
+                    isPrimary: alias.id === args.aliasId,
+                });
+            }
+            await tx.mutate.account.update({
+                id: args.accountId,
+                primaryAliasId: args.aliasId,
+            });
+        }),
+        setConnectionConfigImapRaw: defineMutator(v.object({
+            connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.account.update({
+                id: args.id,
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+            });
+        }),
+        setConnectionConfigOauth: defineMutator(v.object({
+            connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.account.update({
+                id: args.id,
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+            });
+        }),
+        setSettings: defineMutator(v.object({
+            color: v.optional(marcoSchemas.string.nullable()),
+            displayName: v.optional(marcoSchemas.string.nullable()),
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.account.update({
+                color: args.color ? args.color : undefined,
+                displayName: args.displayName ? args.displayName : undefined,
+                id: args.id,
+            });
+        }),
+    },
+    draft: {
+        cancelSend: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            const draft = await tx.run(zql.draft.where('id', args.id).one());
+            if (!draft) {
+                throw new Error(MutationError.ENTITY_NOT_FOUND);
+            }
+            if (draft.status === 'SEND_CONFIRMED') {
+                throw new Error(MutationError.ALREADY_APPLIED);
+            }
+            await tx.mutate.draft.update({
+                id: args.id,
+                scheduledFor: null,
+                status: 'DRAFT',
+                updatedAt: args.updatedAt,
+            });
+        }),
+        createAttachment: defineMutator(v.object({
+            attachment: draftAttachmentSchema,
+            id: marcoSchemas.string.required(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.draftAttachment.insert({
+                draftId: args.id,
+                fileName: args.attachment.fileName,
+                id: args.attachment.id,
+                mimeType: args.attachment.mimeType,
+                status: args.attachment.status,
+                totalSize: args.attachment.totalSize,
+            });
+            await tx.mutate.draft.update({
+                id: args.id,
+                updatedAt: args.updatedAt,
+            });
+        }),
+        createDraft: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            attachments: v.array(draftAttachmentSchema),
+            body: draftBodySchema,
+            error: marcoSchemas.string.nullable(),
+            from: marcoSchemas.string.email(),
+            fromName: marcoSchemas.string.nullable(),
+            id: marcoSchemas.string.required(),
+            referencedMessageId: marcoSchemas.string.nullable(),
+            scheduledFor: v.nullable(marcoSchemas.number.positiveInteger()),
+            status: v.picklist(DRAFT_STATUSES),
+            type: v.picklist(DRAFT_TYPES),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, ctx, args }) => {
+            await tx.mutate.draft.insert({
+                accountId: args.accountId,
+                body: {
+                    bcc: args.body.bcc,
+                    cc: args.body.cc,
+                    content: args.body.content,
+                    to: args.body.to,
+                },
+                error: args.error,
+                fromAliasId: null,
+                fromEmail: args.from,
+                fromName: args.fromName,
+                id: args.id,
+                referencedMessageId: args.referencedMessageId,
+                scheduledFor: args.scheduledFor,
+                status: args.status,
+                subject: args.body.subject,
+                type: args.type,
+                updatedAt: args.updatedAt,
+                userId: ctx.userId,
+            });
+            for (const attachment of args.attachments) {
+                await tx.mutate.draftAttachment.insert({
+                    draftId: args.id,
+                    fileName: attachment.fileName,
+                    id: attachment.id,
+                    mimeType: attachment.mimeType,
+                    status: attachment.status,
+                    totalSize: attachment.totalSize,
+                });
+            }
+        }),
+        deleteAttachment: defineMutator(v.object({
+            attachmentId: marcoSchemas.string.required(),
+            id: marcoSchemas.string.required(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.draftAttachment.delete({
+                id: args.attachmentId,
+            });
+            await tx.mutate.draft.update({
+                id: args.id,
+                updatedAt: args.updatedAt,
+            });
+        }),
+        deleteDraft: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.draft.delete({
+                id: args.id,
+            });
+        }),
+        scheduleSend: defineMutator(v.union([
+            v.object({
+                id: marcoSchemas.string.required(),
+                kind: v.literal('IMMEDIATE'),
+                undoMs: marcoSchemas.number.positiveInteger(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+            v.object({
+                id: marcoSchemas.string.required(),
+                kind: v.literal('SCHEDULED'),
+                scheduledFor: marcoSchemas.number.positiveInteger(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        ]), async ({ tx, args }) => {
+            if (args.kind === 'IMMEDIATE') {
+                await tx.mutate.draft.update({
+                    id: args.id,
+                    scheduledFor: args.updatedAt + args.undoMs,
+                    status: 'SEND_REQUESTED',
+                    updatedAt: args.updatedAt,
+                });
+            }
+            else {
+                await tx.mutate.draft.update({
+                    id: args.id,
+                    scheduledFor: args.scheduledFor,
+                    status: 'SEND_REQUESTED',
+                    updatedAt: args.updatedAt,
+                });
+            }
+        }),
+        setContent: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+            patch: marcoSchemas.drafts.contentPatch.patch(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            const draft = await tx.run(zql.draft.where('id', args.id).one());
+            if (!draft) {
+                throw new Error(MutationError.ENTITY_NOT_FOUND);
+            }
+            await tx.mutate.draft.update({
+                body: {
+                    ...draft.body,
+                    content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', args.patch),
+                },
+                id: args.id,
+                updatedAt: args.updatedAt,
+            });
+        }),
+        setEnvelope: defineMutator(v.object({
+            envelope: v.omit(draftBodySchema, ['content']),
+            id: marcoSchemas.string.required(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            const draft = await tx.run(zql.draft.where('id', args.id).one());
+            if (!draft) {
+                throw new Error(MutationError.ENTITY_NOT_FOUND);
+            }
+            await tx.mutate.draft.update({
+                body: {
+                    bcc: args.envelope.bcc,
+                    cc: args.envelope.cc,
+                    content: draft.body.content,
+                    to: args.envelope.to,
+                },
+                id: args.id,
+                subject: args.envelope.subject,
+                updatedAt: args.updatedAt,
+            });
+        }),
+        setFrom: defineMutator(v.object({
+            accountId: marcoSchemas.string.required(),
+            aliasId: marcoSchemas.string.required(),
+            from: marcoSchemas.string.email(),
+            fromName: marcoSchemas.string.nullable(),
+            id: marcoSchemas.string.required(),
+            updatedAt: marcoSchemas.number.positiveInteger(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.draft.update({
+                accountId: args.accountId,
+                fromAliasId: args.aliasId,
+                fromEmail: args.from,
+                fromName: args.fromName,
+                id: args.id,
+                updatedAt: args.updatedAt,
+            });
+        }),
+    },
+    thread: {
+        addLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
+            for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+                const label = await tx.run(zql.accountLabel.where('accountId', accountId).where('path', args.labelPath).one());
+                if (!label) {
+                    throw new Error(MutationError.ENTITY_NOT_FOUND);
+                }
+                for (const threadId of threadIds) {
+                    const [thread, messages] = await Promise.all([
+                        tx.run(zql.thread.where('id', threadId).one()),
+                        tx.run(zql.threadMessage.where('threadId', threadId)),
+                    ]);
+                    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.run(zql.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one())));
+                    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,
+                            lastSyncedAt: 0,
+                            threadId,
+                            threadMessageId: x.id,
+                            uid: -(baseTimestamp + i),
+                            uidValidity: label.uidValidity ?? 0,
+                        })));
+                    }
+                    currentLabelIds.add(label.id);
+                    await tx.mutate.thread.update({
+                        id: threadId,
+                        labelIdList: buildLabelIdList([...currentLabelIds]),
+                    });
+                }
+            }
+        }),
+        delete: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+            for (const [, { threadIds }] of Object.entries(args.accounts)) {
+                for (const threadId of threadIds) {
+                    const thread = await tx.run(zql.thread.where('id', threadId).one());
+                    if (thread) {
+                        if (thread.seen === false) {
+                            const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
+                            if (labelIds.length > 0) {
+                                const labels = await tx.run(zql.accountLabel.where('id', 'IN', labelIds));
+                                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,
+                        });
+                    }
+                }
+            }
+        }),
+        removeLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
+            for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+                const label = await tx.run(zql.accountLabel.where('accountId', accountId).where('path', args.labelPath).one());
+                if (!label) {
+                    throw new Error(MutationError.ENTITY_NOT_FOUND);
+                }
+                for (const threadId of threadIds) {
+                    const [thread, messages] = await Promise.all([
+                        tx.run(zql.thread.where('id', threadId).one()),
+                        tx.run(zql.threadMessage.where('threadId', threadId)),
+                    ]);
+                    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]),
+                        }),
+                    ]);
+                }
+            }
+        }),
+        setArchive: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+            for (const [, { threadIds }] of Object.entries(args.accounts)) {
+                for (const threadId of threadIds) {
+                    await setSystemLabel(tx, zql, threadId, 'ARCHIVE');
+                }
+            }
+        }),
+        setFlagged: defineMutator(v.object({
+            accounts: accountsSchema,
+            flagged: v.nonOptional(v.boolean()),
+        }), async ({ tx, 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: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+            for (const [, { threadIds }] of Object.entries(args.accounts)) {
+                for (const threadId of threadIds) {
+                    await setSystemLabel(tx, zql, threadId, 'INBOX');
+                }
+            }
+        }),
+        setSeen: defineMutator(v.object({
+            accounts: accountsSchema,
+            seen: v.boolean(),
+        }), async ({ tx, args }) => {
+            const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
+            const threads = await tx.run(zql.thread.where('id', 'IN', allThreadIds));
+            const labelCounts = new Map();
+            for (const thread of threads) {
+                if (thread.seen !== args.seen) {
+                    for (const labelId of threadsUtils.parseLabelIdList(thread.labelIdList)) {
+                        labelCounts.set(labelId, (labelCounts.get(labelId) ?? 0) + 1);
+                    }
+                }
+            }
+            if (labelCounts.size > 0) {
+                const labels = await tx.run(zql.accountLabel.where('id', 'IN', [...labelCounts.keys()]));
+                const delta = args.seen ? -1 : 1;
+                await Promise.all(labels
+                    .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(allThreadIds.map(threadId => tx.mutate.thread.update({
+                id: threadId,
+                seen: args.seen,
+            })));
+        }),
+        setSpam: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+            for (const [, { threadIds }] of Object.entries(args.accounts)) {
+                for (const threadId of threadIds) {
+                    await setSystemLabel(tx, zql, threadId, 'SPAM');
+                }
+            }
+        }),
+        setTrash: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+            for (const [, { threadIds }] of Object.entries(args.accounts)) {
+                for (const threadId of threadIds) {
+                    await setSystemLabel(tx, zql, threadId, 'TRASH');
+                }
+            }
+        }),
+    },
+    user: {
+        deleteSettingsPushNotificationToken: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+            token: marcoSchemas.string.required(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.userPushNotificationToken.delete({
+                id: args.id,
+            });
+        }),
+        setSettingsName: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+            name: marcoSchemas.string.nullable(),
+        }), async ({ tx, args }) => {
+            await tx.mutate.user.update({
+                id: args.id,
+                name: args.name,
+            });
+        }),
+        setSettingsPushNotificationToken: defineMutator(v.object({
+            id: marcoSchemas.string.required(),
+            pushNotificationToken: userPushNotificationTokenSchema,
+        }), async ({ tx, args }) => {
+            const existing = await tx.run(zql.userPushNotificationToken.where('userId', args.id).where('token', args.pushNotificationToken.token).one());
+            if (!existing) {
+                await tx.mutate.userPushNotificationToken.insert({
+                    createdAt: args.pushNotificationToken.createdAt,
+                    id: args.pushNotificationToken.id,
+                    token: args.pushNotificationToken.token,
+                    userId: args.id,
+                });
+            }
+        }),
+    },
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mutators.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutators.test.d.ts","sourceRoot":"","sources":["../../src/zero/mutators.test.ts"],"names":[],"mappings":""}