@marcoappio/marco-config 2.0.492 → 2.0.494

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

@@ -1,8 +1,149 @@
-import type { Transaction } from '@rocicorp/zero';
+import { type Transaction } from '@rocicorp/zero';
 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 declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
-export declare const createThreadMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["thread"]>;
+export declare const setSystemLabel: (tx: Transaction, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
+export declare const threadMutators: {
+    addLabel: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    delete: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    removeLabel: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setArchive: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setFlagged: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        flagged: boolean;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        flagged: boolean;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setInbox: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setSeen: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        seen: boolean;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        seen: boolean;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setSpam: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setTrash: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        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;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"}
+{"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;AAIhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAuB1D,eAAO,MAAM,cAAc,OACrB,WAAW,YACL,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAqGd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgR1B,CAAA"}

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

@@ -1,6 +1,20 @@
+import { defineMutator } from '@rocicorp/zero';
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../schemas';
 import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
+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()),
+}));
+const baseThreadSchema = v.object({
+    accounts: accountsSchema,
+});
+const threadChangeLabelSchema = v.object({
+    accounts: accountsSchema,
+    labelPath: marcoSchemas.string.required(),
+});
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const thread = await tx.query.thread.where('id', threadId).one().run();
     if (!thread) {
@@ -20,28 +34,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,
@@ -49,29 +63,29 @@ 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 createThreadMutators = (_authData) => ({
-    addLabel: async (tx, args) => {
+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();
             if (!label) {
@@ -88,17 +102,17 @@ export const createThreadMutators = (_authData) => ({
                 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,
-                                }),
+                                })),
                             ]
                             : []),
                     ]);
@@ -107,7 +121,7 @@ export const createThreadMutators = (_authData) => ({
                 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,
@@ -115,17 +129,17 @@ export const createThreadMutators = (_authData) => ({
                         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: async (tx, args) => {
+    }),
+    delete: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 const thread = await tx.query.thread.where('id', threadId).one().run();
@@ -134,20 +148,20 @@ export const createThreadMutators = (_authData) => ({
                         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: async (tx, args) => {
+    }),
+    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();
             if (!label) {
@@ -167,54 +181,60 @@ export const createThreadMutators = (_authData) => ({
                 }
                 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: async (tx, args) => {
+    }),
+    setArchive: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'ARCHIVE');
             }
         }
-    },
-    setFlagged: async (tx, args) => {
+    }),
+    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({
+            await Promise.all(threadIds.map(threadId => tx.mutate(zeroCRUD.thread.update({
                 flagged: args.flagged,
                 id: threadId,
-            })));
+            }))));
         }
-    },
-    setInbox: async (tx, args) => {
+    }),
+    setInbox: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'INBOX');
             }
         }
-    },
-    setSeen: async (tx, args) => {
+    }),
+    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.query.thread.where('id', 'IN', allThreadIds).run();
         const labelCounts = new Map();
@@ -230,28 +250,28 @@ export const createThreadMutators = (_authData) => ({
             const delta = args.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,
-        })));
-    },
-    setSpam: async (tx, args) => {
+        }))));
+    }),
+    setSpam: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'SPAM');
             }
         }
-    },
-    setTrash: async (tx, args) => {
+    }),
+    setTrash: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'TRASH');
             }
         }
-    },
-});
+    }),
+};

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

@@ -1,4 +1,38 @@
-import type { AuthData, HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-export declare const createUserMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["user"]>;
+export declare const userMutators: {
+    deleteSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        token: string;
+    }, {
+        id: string;
+        token: string;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setSettingsName: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        name: string | null;
+    }, {
+        id: string;
+        name: string | null;
+    }, {
+        readonly userId: string;
+    }, unknown>;
+    setSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        pushNotificationToken: {
+            createdAt: number;
+            id: string;
+            token: string;
+        };
+    }, {
+        id: string;
+        pushNotificationToken: {
+            createdAt: number;
+            id: string;
+            token: string;
+        };
+    }, {
+        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":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,kBAAkB,cAAe,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CA4BxG,CAAA"}
+{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDxB,CAAA"}

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

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