@marcoappio/marco-config 2.0.493 → 2.0.495

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

@@ -1,7 +1,58 @@
-import type { Transaction } from '@rocicorp/zero';
+import { type Transaction } from '@rocicorp/zero';
+import * as v from 'valibot';
 import type { LabelSpecialUse } from '../../../types';
-import type { MarcoZeroSchema } from '../../../zero/schema';
-export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
+export declare const threadMutatorSchemas: {
+    addLabel: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    delete: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    removeLabel: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    setArchive: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    setFlagged: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+    setInbox: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    setSeen: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly seen: v.BooleanSchema<undefined>;
+    }, undefined>;
+    setSpam: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    setTrash: v.ObjectSchema<{
+        readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+};
+export declare const setSystemLabel: (tx: Transaction, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
 export declare const threadMutators: {
     addLabel: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
@@ -17,7 +68,9 @@ export declare const threadMutators: {
             };
         };
         labelPath: string;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     delete: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -30,7 +83,9 @@ export declare const threadMutators: {
                 threadIds: string[];
             };
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     removeLabel: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -45,7 +100,9 @@ export declare const threadMutators: {
             };
         };
         labelPath: string;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setArchive: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -58,7 +115,9 @@ export declare const threadMutators: {
                 threadIds: string[];
             };
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setFlagged: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -73,7 +132,9 @@ export declare const threadMutators: {
             };
         };
         flagged: boolean;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setInbox: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -86,7 +147,9 @@ export declare const threadMutators: {
                 threadIds: string[];
             };
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setSeen: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -101,7 +164,9 @@ export declare const threadMutators: {
             };
         };
         seen: boolean;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setSpam: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -114,7 +179,9 @@ export declare const threadMutators: {
                 threadIds: string[];
             };
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setTrash: import("@rocicorp/zero").MutatorDefinition<{
         accounts: {
             [x: string]: {
@@ -127,6 +194,8 @@ export declare const threadMutators: {
                 threadIds: string[];
             };
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
 };
 //# 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;AAIjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAoBhE,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsP1B,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAuB1D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhC,CAAA;AAED,eAAO,MAAM,cAAc,OACrB,WAAW,YACL,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAqGd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQ1B,CAAA"}

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

@@ -1,8 +1,9 @@
+import { defineMutator } from '@rocicorp/zero';
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../schemas';
 import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
-import { defineMutator } from '../../../zero/mutators/defineMutator';
+import { zeroCRUD } from '../../../zero/crud';
 const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
 const accountsSchema = v.record(marcoSchemas.string.required(), v.object({
     threadIds: v.array(marcoSchemas.string.required()),
@@ -14,6 +15,23 @@ const threadChangeLabelSchema = v.object({
     accounts: accountsSchema,
     labelPath: marcoSchemas.string.required(),
 });
+export const threadMutatorSchemas = {
+    addLabel: threadChangeLabelSchema,
+    delete: baseThreadSchema,
+    removeLabel: threadChangeLabelSchema,
+    setArchive: baseThreadSchema,
+    setFlagged: v.object({
+        accounts: accountsSchema,
+        flagged: v.nonOptional(v.boolean()),
+    }),
+    setInbox: baseThreadSchema,
+    setSeen: v.object({
+        accounts: accountsSchema,
+        seen: v.boolean(),
+    }),
+    setSpam: baseThreadSchema,
+    setTrash: baseThreadSchema,
+};
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const thread = await tx.query.thread.where('id', threadId).one().run();
     if (!thread) {
@@ -33,28 +51,28 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const threadLabelDeletes = [];
     for (const message of messages) {
         for (const labelId of labelIdsToRemove) {
-            threadLabelDeletes.push(tx.mutate.threadLabel.delete({
+            threadLabelDeletes.push(tx.mutate(zeroCRUD.threadLabel.delete({
                 accountId: thread.accountId,
                 labelId,
                 threadMessageId: message.id,
-            }));
+            })));
         }
     }
     await Promise.all([
         ...threadLabelDeletes,
-        ...[...labelIdsToRemove].map(labelId => tx.mutate.threadByLabel.delete({ labelId, threadId })),
+        ...[...labelIdsToRemove].map(labelId => tx.mutate(zeroCRUD.threadByLabel.delete({ labelId, threadId }))),
     ]);
     if (thread.seen === false && labelIdsToRemove.size > 0) {
         const labelsToUpdate = await tx.query.accountLabel.where('id', 'IN', [...labelIdsToRemove]).run();
-        await Promise.all(labelsToUpdate.map(label => tx.mutate.accountLabel.update({
+        await Promise.all(labelsToUpdate.map(label => tx.mutate(zeroCRUD.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({
+            ...messages.map((message, i) => tx.mutate(zeroCRUD.threadLabel.insert({
                 accountId: thread.accountId,
                 labelId: targetLabel.id,
                 lastSyncedAt: 0,
@@ -62,31 +80,31 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
                 threadMessageId: message.id,
                 uid: -(baseTimestamp + i),
                 uidValidity: targetLabel.uidValidity ?? 0,
-            })),
-            tx.mutate.threadByLabel.insert({
+            }))),
+            tx.mutate(zeroCRUD.threadByLabel.insert({
                 labelId: targetLabel.id,
                 latestMessageDate: thread.latestMessageDate,
                 threadId,
-            }),
+            })),
             ...(thread.seen === false
                 ? [
-                    tx.mutate.accountLabel.update({
+                    tx.mutate(zeroCRUD.accountLabel.update({
                         id: targetLabel.id,
                         unreadCount: (targetLabel.unreadCount ?? 0) + 1,
-                    }),
+                    })),
                 ]
                 : []),
         ]);
     }
-    await tx.mutate.thread.update({
+    await tx.mutate(zeroCRUD.thread.update({
         id: threadId,
         labelIdList: buildLabelIdList([targetLabel.id]),
-    });
+    }));
 };
 export const threadMutators = {
-    addLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
-        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
-            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
+    addLabel: defineMutator(threadMutatorSchemas.addLabel, async ({ tx, args: { accounts, labelPath } }) => {
+        for (const [accountId, { threadIds }] of Object.entries(accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
@@ -101,17 +119,17 @@ export const threadMutators = {
                 const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
                 if (!currentLabelIds.has(label.id)) {
                     await Promise.all([
-                        tx.mutate.threadByLabel.insert({
+                        tx.mutate(zeroCRUD.threadByLabel.insert({
                             labelId: label.id,
                             latestMessageDate: thread.latestMessageDate,
                             threadId,
-                        }),
+                        })),
                         ...(thread.seen === false
                             ? [
-                                tx.mutate.accountLabel.update({
+                                tx.mutate(zeroCRUD.accountLabel.update({
                                     id: label.id,
                                     unreadCount: (label.unreadCount ?? 0) + 1,
-                                }),
+                                })),
                             ]
                             : []),
                     ]);
@@ -120,7 +138,7 @@ export const threadMutators = {
                 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({
+                    await Promise.all(messagesToInsert.map((x, i) => tx.mutate(zeroCRUD.threadLabel.insert({
                         accountId,
                         labelId: label.id,
                         lastSyncedAt: 0,
@@ -128,18 +146,18 @@ export const threadMutators = {
                         threadMessageId: x.id,
                         uid: -(baseTimestamp + i),
                         uidValidity: label.uidValidity ?? 0,
-                    })));
+                    }))));
                 }
                 currentLabelIds.add(label.id);
-                await tx.mutate.thread.update({
+                await tx.mutate(zeroCRUD.thread.update({
                     id: threadId,
                     labelIdList: buildLabelIdList([...currentLabelIds]),
-                });
+                }));
             }
         }
     }),
-    delete: defineMutator(baseThreadSchema, async ({ tx, args }) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+    delete: defineMutator(threadMutatorSchemas.delete, async ({ tx, args: { accounts } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
                 const thread = await tx.query.thread.where('id', threadId).one().run();
                 if (thread) {
@@ -147,22 +165,22 @@ export const threadMutators = {
                         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({
+                            await Promise.all(labels.map(x => tx.mutate(zeroCRUD.accountLabel.update({
                                 id: x.id,
                                 unreadCount: Math.max(0, (x.unreadCount ?? 0) - 1),
-                            })));
+                            }))));
                         }
                     }
-                    await tx.mutate.thread.delete({
+                    await tx.mutate(zeroCRUD.thread.delete({
                         id: threadId,
-                    });
+                    }));
                 }
             }
         }
     }),
-    removeLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
-        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
-            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
+    removeLabel: defineMutator(threadMutatorSchemas.removeLabel, async ({ tx, args: { accounts, labelPath } }) => {
+        for (const [accountId, { threadIds }] of Object.entries(accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
@@ -180,65 +198,59 @@ export const threadMutators = {
                 }
                 currentLabelIds.delete(label.id);
                 await Promise.all([
-                    ...messages.map(x => tx.mutate.threadLabel.delete({
+                    ...messages.map(x => tx.mutate(zeroCRUD.threadLabel.delete({
                         accountId,
                         labelId: label.id,
                         threadMessageId: x.id,
-                    })),
-                    tx.mutate.threadByLabel.delete({
+                    }))),
+                    tx.mutate(zeroCRUD.threadByLabel.delete({
                         labelId: label.id,
                         threadId,
-                    }),
+                    })),
                     ...(thread.seen === false
                         ? [
-                            tx.mutate.accountLabel.update({
+                            tx.mutate(zeroCRUD.accountLabel.update({
                                 id: label.id,
                                 unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-                            }),
+                            })),
                         ]
                         : []),
-                    tx.mutate.thread.update({
+                    tx.mutate(zeroCRUD.thread.update({
                         id: threadId,
                         labelIdList: buildLabelIdList([...currentLabelIds]),
-                    }),
+                    })),
                 ]);
             }
         }
     }),
-    setArchive: defineMutator(baseThreadSchema, async ({ tx, args }) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+    setArchive: defineMutator(threadMutatorSchemas.setArchive, async ({ tx, args: { accounts } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, 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,
+    setFlagged: defineMutator(threadMutatorSchemas.setFlagged, async ({ tx, args: { accounts, flagged } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
+            await Promise.all(threadIds.map(threadId => tx.mutate(zeroCRUD.thread.update({
+                flagged,
                 id: threadId,
-            })));
+            }))));
         }
     }),
-    setInbox: defineMutator(baseThreadSchema, async ({ tx, args }) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+    setInbox: defineMutator(threadMutatorSchemas.setInbox, async ({ tx, args: { accounts } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'INBOX');
             }
         }
     }),
-    setSeen: defineMutator(v.object({
-        accounts: accountsSchema,
-        seen: v.boolean(),
-    }), async ({ tx, args }) => {
-        const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
+    setSeen: defineMutator(threadMutatorSchemas.setSeen, async ({ tx, args: { accounts, seen } }) => {
+        const allThreadIds = Object.values(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) {
+            if (thread.seen !== seen) {
                 for (const labelId of threadsUtils.parseLabelIdList(thread.labelIdList)) {
                     labelCounts.set(labelId, (labelCounts.get(labelId) ?? 0) + 1);
                 }
@@ -246,28 +258,28 @@ export const threadMutators = {
         }
         if (labelCounts.size > 0) {
             const labels = await tx.query.accountLabel.where('id', 'IN', [...labelCounts.keys()]).run();
-            const delta = args.seen ? -1 : 1;
+            const delta = seen ? -1 : 1;
             await Promise.all(labels
                 .filter(x => labelCounts.has(x.id))
-                .map(x => tx.mutate.accountLabel.update({
+                .map(x => tx.mutate(zeroCRUD.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({
+        await Promise.all(allThreadIds.map(threadId => tx.mutate(zeroCRUD.thread.update({
             id: threadId,
-            seen: args.seen,
-        })));
+            seen,
+        }))));
     }),
-    setSpam: defineMutator(baseThreadSchema, async ({ tx, args }) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+    setSpam: defineMutator(threadMutatorSchemas.setSpam, async ({ tx, args: { accounts } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'SPAM');
             }
         }
     }),
-    setTrash: defineMutator(baseThreadSchema, async ({ tx, args }) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+    setTrash: defineMutator(threadMutatorSchemas.setTrash, async ({ tx, args: { accounts } }) => {
+        for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'TRASH');
             }

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

@@ -1,2 +1,2 @@
-export * from './userMutators';
+export { userMutatorSchemas, userMutators } from './userMutators';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/zero/mutators/userMutators/index.js

@@ -1 +1 @@
-export * from './userMutators';
+export { userMutatorSchemas, userMutators } from './userMutators';

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

@@ -1,3 +1,22 @@
+import * as v from 'valibot';
+export declare const userMutatorSchemas: {
+    deleteSettingsPushNotificationToken: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    setSettingsName: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    setSettingsPushNotificationToken: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly pushNotificationToken: v.ObjectSchema<{
+            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+};
 export declare const userMutators: {
     deleteSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
@@ -5,14 +24,18 @@ export declare const userMutators: {
     }, {
         id: string;
         token: string;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setSettingsName: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
         name: string | null;
     }, {
         id: string;
         name: string | null;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
         pushNotificationToken: {
@@ -27,6 +50,8 @@ export declare const userMutators: {
             id: string;
             token: string;
         };
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
 };
 //# sourceMappingURL=userMutators.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CxB,CAAA"}
+{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAiB9B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxB,CAAA"}

package/dist/zero/mutators/userMutators/userMutators.js

@@ -1,45 +1,45 @@
+import { defineMutator } from '@rocicorp/zero';
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../schemas';
-import { defineMutator } from '../../../zero/mutators/defineMutator';
-const userPushNotificationTokenSchema = v.object({
-    createdAt: marcoSchemas.number.positiveInteger(),
-    id: marcoSchemas.string.required(),
-    token: marcoSchemas.string.required(),
-});
-export const userMutators = {
-    deleteSettingsPushNotificationToken: defineMutator(v.object({
+import { zeroCRUD } from '../../../zero/crud';
+export const userMutatorSchemas = {
+    deleteSettingsPushNotificationToken: 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({
+    setSettingsName: 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({
+    setSettingsPushNotificationToken: v.object({
         id: marcoSchemas.string.required(),
-        pushNotificationToken: userPushNotificationTokenSchema,
-    }), async ({ tx, args }) => {
+        pushNotificationToken: v.object({
+            createdAt: marcoSchemas.number.positiveInteger(),
+            id: marcoSchemas.string.required(),
+            token: marcoSchemas.string.required(),
+        }),
+    }),
+};
+export const userMutators = {
+    deleteSettingsPushNotificationToken: defineMutator(userMutatorSchemas.deleteSettingsPushNotificationToken, async ({ tx, args: { id } }) => {
+        await tx.mutate(zeroCRUD.userPushNotificationToken.delete({ id }));
+    }),
+    setSettingsName: defineMutator(userMutatorSchemas.setSettingsName, async ({ tx, args: { id, name } }) => {
+        await tx.mutate(zeroCRUD.user.update({ id, name }));
+    }),
+    setSettingsPushNotificationToken: defineMutator(userMutatorSchemas.setSettingsPushNotificationToken, async ({ tx, args: { id, pushNotificationToken } }) => {
         const existing = await tx.query.userPushNotificationToken
-            .where('userId', args.id)
-            .where('token', args.pushNotificationToken.token)
+            .where('userId', id)
+            .where('token', pushNotificationToken.token)
             .one()
             .run();
         if (!existing) {
-            await tx.mutate.userPushNotificationToken.insert({
-                createdAt: args.pushNotificationToken.createdAt,
-                id: args.pushNotificationToken.id,
-                token: args.pushNotificationToken.token,
-                userId: args.id,
-            });
+            await tx.mutate(zeroCRUD.userPushNotificationToken.insert({
+                createdAt: pushNotificationToken.createdAt,
+                id: pushNotificationToken.id,
+                token: pushNotificationToken.token,
+                userId: id,
+            }));
         }
     }),
 };

package/dist/zero/queries/getAccounts.d.ts

@@ -1020,7 +1020,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
         };
     };
     enableLegacyQueries: boolean | undefined;
-    enableLegacyMutators: false;
+    enableLegacyMutators: boolean | undefined;
 }, {
     readonly color: string;
     readonly displayName: string | null;