@marcoappio/marco-config 2.0.511 → 2.0.512

package/dist/zero/mutators.js

@@ -1,46 +1,11 @@
 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 { MutationError } from '../types';
 import { stringPatch } from '../utils';
 import { threadsUtils } from '../utils/threads';
-import { schema } from './schema';
+import { mutatorSchemas } from '../zero/mutatorSchemas';
+import { schema } from '../zero/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());
@@ -113,12 +78,7 @@ const setSystemLabel = async (tx, builder, threadId, targetSpecialUse) => {
 };
 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 }) => {
+        createAccount: defineMutator(mutatorSchemas.account.createAccount, async ({ tx, ctx, args }) => {
             await tx.mutate.account.insert({
                 color: args.color,
                 displayName: null,
@@ -137,10 +97,7 @@ export const mutators = defineMutators({
                 name: null,
             });
         }),
-        createAlias: defineMutator(v.object({
-            accountId: marcoSchemas.string.required(),
-            alias: accountAliasSchema,
-        }), async ({ tx, args }) => {
+        createAlias: defineMutator(mutatorSchemas.account.createAlias, async ({ tx, args }) => {
             await tx.mutate.accountAlias.insert({
                 accountId: args.accountId,
                 emailAddress: args.alias.emailAddress,
@@ -149,17 +106,12 @@ export const mutators = defineMutators({
                 name: args.alias.name ?? null,
             });
         }),
-        deleteAccount: defineMutator(v.object({
-            id: marcoSchemas.string.required(),
-        }), async ({ tx, args }) => {
+        deleteAccount: defineMutator(mutatorSchemas.account.deleteAccount, 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 }) => {
+        deleteAlias: defineMutator(mutatorSchemas.account.deleteAlias, async ({ tx, args }) => {
             const alias = await tx.run(zql.accountAlias.where('id', args.aliasId).one());
             await tx.mutate.accountAlias.delete({
                 id: args.aliasId,
@@ -185,20 +137,13 @@ export const mutators = defineMutators({
                 }
             }
         }),
-        setAliasName: defineMutator(v.object({
-            accountId: marcoSchemas.string.required(),
-            aliasId: marcoSchemas.string.required(),
-            displayName: marcoSchemas.string.nullable(),
-        }), async ({ tx, args }) => {
+        setAliasName: defineMutator(mutatorSchemas.account.setAliasName, 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 }) => {
+        setAliasPrimary: defineMutator(mutatorSchemas.account.setAliasPrimary, async ({ tx, args }) => {
             const aliases = await tx.run(zql.accountAlias.where('accountId', args.accountId));
             for (const alias of aliases) {
                 await tx.mutate.accountAlias.update({
@@ -211,29 +156,19 @@ export const mutators = defineMutators({
                 primaryAliasId: args.aliasId,
             });
         }),
-        setConnectionConfigImapRaw: defineMutator(v.object({
-            connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
-            id: marcoSchemas.string.required(),
-        }), async ({ tx, args }) => {
+        setConnectionConfigImapRaw: defineMutator(mutatorSchemas.account.setConnectionConfigImapRaw, 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 }) => {
+        setConnectionConfigOauth: defineMutator(mutatorSchemas.account.setConnectionConfigOauth, 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 }) => {
+        setSettings: defineMutator(mutatorSchemas.account.setSettings, async ({ tx, args }) => {
             await tx.mutate.account.update({
                 color: args.color ? args.color : undefined,
                 displayName: args.displayName ? args.displayName : undefined,
@@ -242,10 +177,7 @@ export const mutators = defineMutators({
         }),
     },
     draft: {
-        cancelSend: defineMutator(v.object({
-            id: marcoSchemas.string.required(),
-            updatedAt: marcoSchemas.number.positiveInteger(),
-        }), async ({ tx, args }) => {
+        cancelSend: defineMutator(mutatorSchemas.draft.cancelSend, async ({ tx, args }) => {
             const draft = await tx.run(zql.draft.where('id', args.id).one());
             if (!draft) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -260,11 +192,7 @@ export const mutators = defineMutators({
                 updatedAt: args.updatedAt,
             });
         }),
-        createAttachment: defineMutator(v.object({
-            attachment: draftAttachmentSchema,
-            id: marcoSchemas.string.required(),
-            updatedAt: marcoSchemas.number.positiveInteger(),
-        }), async ({ tx, args }) => {
+        createAttachment: defineMutator(mutatorSchemas.draft.createAttachment, async ({ tx, args }) => {
             await tx.mutate.draftAttachment.insert({
                 draftId: args.id,
                 fileName: args.attachment.fileName,
@@ -278,20 +206,7 @@ export const mutators = defineMutators({
                 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 }) => {
+        createDraft: defineMutator(mutatorSchemas.draft.createDraft, async ({ tx, ctx, args }) => {
             await tx.mutate.draft.insert({
                 accountId: args.accountId,
                 body: {
@@ -324,11 +239,7 @@ export const mutators = defineMutators({
                 });
             }
         }),
-        deleteAttachment: defineMutator(v.object({
-            attachmentId: marcoSchemas.string.required(),
-            id: marcoSchemas.string.required(),
-            updatedAt: marcoSchemas.number.positiveInteger(),
-        }), async ({ tx, args }) => {
+        deleteAttachment: defineMutator(mutatorSchemas.draft.deleteAttachment, async ({ tx, args }) => {
             await tx.mutate.draftAttachment.delete({
                 id: args.attachmentId,
             });
@@ -337,27 +248,12 @@ export const mutators = defineMutators({
                 updatedAt: args.updatedAt,
             });
         }),
-        deleteDraft: defineMutator(v.object({
-            id: marcoSchemas.string.required(),
-        }), async ({ tx, args }) => {
+        deleteDraft: defineMutator(mutatorSchemas.draft.deleteDraft, 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 }) => {
+        scheduleSend: defineMutator(mutatorSchemas.draft.scheduleSend, async ({ tx, args }) => {
             if (args.kind === 'IMMEDIATE') {
                 await tx.mutate.draft.update({
                     id: args.id,
@@ -375,11 +271,7 @@ export const mutators = defineMutators({
                 });
             }
         }),
-        setContent: defineMutator(v.object({
-            id: marcoSchemas.string.required(),
-            patch: marcoSchemas.drafts.contentPatch.patch(),
-            updatedAt: marcoSchemas.number.positiveInteger(),
-        }), async ({ tx, args }) => {
+        setContent: defineMutator(mutatorSchemas.draft.setContent, async ({ tx, args }) => {
             const draft = await tx.run(zql.draft.where('id', args.id).one());
             if (!draft) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -393,11 +285,7 @@ export const mutators = defineMutators({
                 updatedAt: args.updatedAt,
             });
         }),
-        setEnvelope: defineMutator(v.object({
-            envelope: v.omit(draftBodySchema, ['content']),
-            id: marcoSchemas.string.required(),
-            updatedAt: marcoSchemas.number.positiveInteger(),
-        }), async ({ tx, args }) => {
+        setEnvelope: defineMutator(mutatorSchemas.draft.setEnvelope, async ({ tx, args }) => {
             const draft = await tx.run(zql.draft.where('id', args.id).one());
             if (!draft) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -414,14 +302,7 @@ export const mutators = defineMutators({
                 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 }) => {
+        setFrom: defineMutator(mutatorSchemas.draft.setFrom, async ({ tx, args }) => {
             await tx.mutate.draft.update({
                 accountId: args.accountId,
                 fromAliasId: args.aliasId,
@@ -433,7 +314,7 @@ export const mutators = defineMutators({
         }),
     },
     thread: {
-        addLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
+        addLabel: defineMutator(mutatorSchemas.thread.addLabel, 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) {
@@ -487,7 +368,7 @@ export const mutators = defineMutators({
                 }
             }
         }),
-        delete: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+        delete: defineMutator(mutatorSchemas.thread.delete, 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());
@@ -509,7 +390,7 @@ export const mutators = defineMutators({
                 }
             }
         }),
-        removeLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
+        removeLabel: defineMutator(mutatorSchemas.thread.removeLabel, 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) {
@@ -554,17 +435,14 @@ export const mutators = defineMutators({
                 }
             }
         }),
-        setArchive: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+        setArchive: defineMutator(mutatorSchemas.thread.setArchive, 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 }) => {
+        setFlagged: defineMutator(mutatorSchemas.thread.setFlagged, async ({ tx, args }) => {
             for (const [, { threadIds }] of Object.entries(args.accounts)) {
                 await Promise.all(threadIds.map(threadId => tx.mutate.thread.update({
                     flagged: args.flagged,
@@ -572,17 +450,14 @@ export const mutators = defineMutators({
                 })));
             }
         }),
-        setInbox: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+        setInbox: defineMutator(mutatorSchemas.thread.setInbox, 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 }) => {
+        setSeen: defineMutator(mutatorSchemas.thread.setSeen, 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();
@@ -608,14 +483,14 @@ export const mutators = defineMutators({
                 seen: args.seen,
             })));
         }),
-        setSpam: defineMutator(baseThreadSchema, async ({ tx, args }) => {
+        setSpam: defineMutator(mutatorSchemas.thread.setSpam, 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 }) => {
+        setTrash: defineMutator(mutatorSchemas.thread.setTrash, async ({ tx, args }) => {
             for (const [, { threadIds }] of Object.entries(args.accounts)) {
                 for (const threadId of threadIds) {
                     await setSystemLabel(tx, zql, threadId, 'TRASH');
@@ -624,27 +499,18 @@ export const mutators = defineMutators({
         }),
     },
     user: {
-        deleteSettingsPushNotificationToken: defineMutator(v.object({
-            id: marcoSchemas.string.required(),
-            token: marcoSchemas.string.required(),
-        }), async ({ tx, args }) => {
+        deleteSettingsPushNotificationToken: defineMutator(mutatorSchemas.user.deleteSettingsPushNotificationToken, 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 }) => {
+        setSettingsName: defineMutator(mutatorSchemas.user.setSettingsName, 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 }) => {
+        setSettingsPushNotificationToken: defineMutator(mutatorSchemas.user.setSettingsPushNotificationToken, 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({