@marcoappio/marco-config 2.0.494 → 2.0.495

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

@@ -2,65 +2,88 @@ import { defineMutator } from '@rocicorp/zero';
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../schemas';
 import { zeroCRUD } from '../../../zero/crud';
-const accountAliasSchema = v.object({
-    emailAddress: marcoSchemas.string.email(),
-    id: marcoSchemas.string.required(),
-    name: marcoSchemas.string.nullable(),
-});
-export const accountMutators = {
-    createAccount: defineMutator(v.object({
+export const accountMutatorSchemas = {
+    createAccount: v.object({
         aliasId: marcoSchemas.string.required(),
         color: marcoSchemas.string.required(),
         emailAddress: marcoSchemas.string.email(),
         id: marcoSchemas.string.required(),
-    }), async ({ tx, ctx: { userId }, args }) => {
+    }),
+    createAlias: v.object({
+        accountId: marcoSchemas.string.required(),
+        alias: v.object({
+            emailAddress: marcoSchemas.string.email(),
+            id: marcoSchemas.string.required(),
+            name: marcoSchemas.string.nullable(),
+        }),
+    }),
+    deleteAccount: v.object({
+        id: marcoSchemas.string.required(),
+    }),
+    deleteAlias: v.object({
+        accountId: marcoSchemas.string.required(),
+        aliasId: marcoSchemas.string.required(),
+    }),
+    setAliasName: v.object({
+        accountId: marcoSchemas.string.required(),
+        aliasId: marcoSchemas.string.required(),
+        displayName: marcoSchemas.string.nullable(),
+    }),
+    setAliasPrimary: v.object({
+        accountId: marcoSchemas.string.required(),
+        aliasId: marcoSchemas.string.required(),
+    }),
+    setConnectionConfigImapRaw: v.object({
+        connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
+        id: marcoSchemas.string.required(),
+    }),
+    setConnectionConfigOauth: v.object({
+        connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
+        id: marcoSchemas.string.required(),
+    }),
+    setSettings: v.object({
+        color: v.optional(marcoSchemas.string.nullable()),
+        displayName: v.optional(marcoSchemas.string.nullable()),
+        id: marcoSchemas.string.required(),
+    }),
+};
+export const accountMutators = {
+    createAccount: defineMutator(accountMutatorSchemas.createAccount, async ({ tx, ctx: { userId }, args: { color, id, aliasId, emailAddress } }) => {
         await tx.mutate(zeroCRUD.account.insert({
-            color: args.color,
+            color,
             displayName: null,
-            id: args.id,
+            id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
             mailProcessedCount: 0,
             mailTotalCount: 0,
-            primaryAliasId: args.aliasId,
+            primaryAliasId: aliasId,
             userId,
         }));
         await tx.mutate(zeroCRUD.accountAlias.insert({
-            accountId: args.id,
-            emailAddress: args.emailAddress,
-            id: args.aliasId,
+            accountId: id,
+            emailAddress,
+            id: aliasId,
             isPrimary: true,
             name: null,
         }));
     }),
-    createAlias: defineMutator(v.object({
-        accountId: marcoSchemas.string.required(),
-        alias: accountAliasSchema,
-    }), async ({ tx, args }) => {
+    createAlias: defineMutator(accountMutatorSchemas.createAlias, async ({ tx, args: { accountId, alias } }) => {
         await tx.mutate(zeroCRUD.accountAlias.insert({
-            accountId: args.accountId,
-            emailAddress: args.alias.emailAddress,
-            id: args.alias.id,
+            accountId: accountId,
+            emailAddress: alias.emailAddress,
+            id: alias.id,
             isPrimary: false,
-            name: args.alias.name ?? null,
+            name: alias.name ?? null,
         }));
     }),
-    deleteAccount: defineMutator(v.object({
-        id: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        await tx.mutate(zeroCRUD.account.delete({
-            id: args.id,
-        }));
+    deleteAccount: defineMutator(accountMutatorSchemas.deleteAccount, async ({ tx, args: { id } }) => {
+        await tx.mutate(zeroCRUD.account.delete({ id }));
     }),
-    deleteAlias: defineMutator(v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        const alias = await tx.query.accountAlias.where('id', args.aliasId).one().run();
-        await tx.mutate(zeroCRUD.accountAlias.delete({
-            id: args.aliasId,
-        }));
+    deleteAlias: defineMutator(accountMutatorSchemas.deleteAlias, async ({ tx, args: { accountId, aliasId } }) => {
+        const alias = await tx.query.accountAlias.where('id', aliasId).one().run();
+        await tx.mutate(zeroCRUD.accountAlias.delete({ id: aliasId }));
         if (alias?.isPrimary) {
-            const remainingAliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
+            const remainingAliases = await tx.query.accountAlias.where('accountId', accountId).run();
             if (remainingAliases.length > 0) {
                 const newPrimaryAlias = remainingAliases[0];
                 await tx.mutate(zeroCRUD.accountAlias.update({
@@ -68,71 +91,48 @@ export const accountMutators = {
                     isPrimary: true,
                 }));
                 await tx.mutate(zeroCRUD.account.update({
-                    id: args.accountId,
+                    id: accountId,
                     primaryAliasId: newPrimaryAlias.id,
                 }));
             }
             else {
                 await tx.mutate(zeroCRUD.account.update({
-                    id: args.accountId,
+                    id: accountId,
                     primaryAliasId: null,
                 }));
             }
         }
     }),
-    setAliasName: defineMutator(v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-        displayName: marcoSchemas.string.nullable(),
-    }), async ({ tx, args }) => {
+    setAliasName: defineMutator(accountMutatorSchemas.setAliasName, async ({ tx, args: { aliasId, displayName } }) => {
         await tx.mutate(zeroCRUD.accountAlias.update({
-            id: args.aliasId,
-            name: args.displayName,
+            id: aliasId,
+            name: displayName,
         }));
     }),
-    setAliasPrimary: defineMutator(v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
+    setAliasPrimary: defineMutator(accountMutatorSchemas.setAliasPrimary, async ({ tx, args: { accountId, aliasId } }) => {
+        const aliases = await tx.query.accountAlias.where('accountId', accountId).run();
         for (const alias of aliases) {
             await tx.mutate(zeroCRUD.accountAlias.update({
                 id: alias.id,
-                isPrimary: alias.id === args.aliasId,
+                isPrimary: alias.id === aliasId,
             }));
         }
         await tx.mutate(zeroCRUD.account.update({
-            id: args.accountId,
-            primaryAliasId: args.aliasId,
+            id: accountId,
+            primaryAliasId: aliasId,
         }));
     }),
-    setConnectionConfigImapRaw: defineMutator(v.object({
-        connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
-        id: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        await tx.mutate(zeroCRUD.account.update({
-            id: args.id,
-            imapConnectionStatus: 'AWAITING_CONNECTION',
-        }));
+    setConnectionConfigImapRaw: defineMutator(accountMutatorSchemas.setConnectionConfigImapRaw, async ({ tx, args: { id } }) => {
+        await tx.mutate(zeroCRUD.account.update({ id, imapConnectionStatus: 'AWAITING_CONNECTION' }));
     }),
-    setConnectionConfigOauth: defineMutator(v.object({
-        connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
-        id: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        await tx.mutate(zeroCRUD.account.update({
-            id: args.id,
-            imapConnectionStatus: 'AWAITING_CONNECTION',
-        }));
+    setConnectionConfigOauth: defineMutator(accountMutatorSchemas.setConnectionConfigOauth, async ({ tx, args: { id } }) => {
+        await tx.mutate(zeroCRUD.account.update({ 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(accountMutatorSchemas.setSettings, async ({ tx, args: { id, color, displayName } }) => {
         await tx.mutate(zeroCRUD.account.update({
-            color: args.color ? args.color : undefined,
-            displayName: args.displayName ? args.displayName : undefined,
-            id: args.id,
+            color: color ? color : undefined,
+            displayName: displayName ? displayName : undefined,
+            id,
         }));
     }),
 };

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

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

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

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

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

@@ -1 +1 @@
-export * from './accountMutators';
+export { accountMutatorSchemas, accountMutators } from './accountMutators';

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

@@ -1,3 +1,97 @@
+import * as v from 'valibot';
+export declare const draftMutatorSchemas: {
+    cancelSend: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    createAttachment: v.ObjectSchema<{
+        readonly attachment: v.ObjectSchema<{
+            readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly status: v.PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
+            readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    deleteAttachment: v.ObjectSchema<{
+        readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    deleteDraft: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    setContent: v.ObjectSchema<{
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly patch: v.ArraySchema<v.ObjectSchema<{
+            readonly index: v.NumberSchema<undefined>;
+            readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
+            readonly value: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    setEnvelope: v.ObjectSchema<{
+        readonly envelope: Omit<v.ObjectSchema<{
+            readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+            readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+        }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
+            readonly entries: Omit<{
+                readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+                readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            }, "content">;
+            readonly '~standard': v.StandardProps<{
+                bcc: string[];
+                cc: string[];
+                to: string[];
+                subject: string | null;
+            }, {
+                bcc: string[];
+                cc: string[];
+                to: string[];
+                subject: string | null;
+            }>;
+            readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                bcc: string[];
+                cc: string[];
+                to: string[];
+                subject: string | null;
+            }, v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue | v.ArrayIssue | v.NonOptionalIssue>;
+            readonly '~types'?: {
+                readonly input: {
+                    bcc: string[];
+                    cc: string[];
+                    to: string[];
+                    subject: string | null;
+                };
+                readonly output: {
+                    bcc: string[];
+                    cc: string[];
+                    to: string[];
+                    subject: string | null;
+                };
+                readonly issue: v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue | v.ArrayIssue | v.NonOptionalIssue;
+            } | undefined;
+        };
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    setFrom: v.ObjectSchema<{
+        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly from: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly fromName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+};
 export declare const draftMutators: {
     cancelSend: import("@rocicorp/zero").MutatorDefinition<{
         id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAyDA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgOzB,CAAA"}
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAqD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKzB,CAAA"}

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

@@ -4,8 +4,6 @@ import { marcoSchemas } from '../../../schemas';
 import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, MutationError } from '../../../types';
 import { stringPatch } from '../../../utils';
 import { zeroCRUD } from '../../../zero/crud';
-const draftStatusSchema = v.picklist(DRAFT_STATUSES);
-const draftTypeSchema = v.picklist(DRAFT_TYPES);
 const draftBodySchema = v.object({
     bcc: v.array(marcoSchemas.string.email()),
     cc: v.array(marcoSchemas.string.email()),
@@ -44,16 +42,50 @@ const draftModelSchema = v.object({
     id: marcoSchemas.string.required(),
     referencedMessageId: marcoSchemas.string.nullable(),
     scheduledFor: v.nullable(marcoSchemas.number.positiveInteger()),
-    status: draftStatusSchema,
-    type: draftTypeSchema,
+    status: v.picklist(DRAFT_STATUSES),
+    type: v.picklist(DRAFT_TYPES),
     updatedAt: marcoSchemas.number.positiveInteger(),
 });
-export const draftMutators = {
-    cancelSend: defineMutator(v.object({
+export const draftMutatorSchemas = {
+    cancelSend: v.object({
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    createAttachment: v.object({
+        attachment: draftAttachmentSchema,
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    deleteAttachment: v.object({
+        attachmentId: marcoSchemas.string.required(),
         id: marcoSchemas.string.required(),
         updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
-        const draft = await tx.query.draft.where('id', args.id).one().run();
+    }),
+    deleteDraft: v.object({
+        id: marcoSchemas.string.required(),
+    }),
+    setContent: v.object({
+        id: marcoSchemas.string.required(),
+        patch: marcoSchemas.drafts.contentPatch.patch(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    setEnvelope: v.object({
+        envelope: v.omit(draftBodySchema, ['content']),
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    setFrom: 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(),
+    }),
+};
+export const draftMutators = {
+    cancelSend: defineMutator(draftMutatorSchemas.cancelSend, async ({ tx, args: { id, updatedAt } }) => {
+        const draft = await tx.query.draft.where('id', id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
@@ -61,29 +93,22 @@ export const draftMutators = {
             throw new Error(MutationError.ALREADY_APPLIED);
         }
         await tx.mutate(zeroCRUD.draft.update({
-            id: args.id,
+            id,
             scheduledFor: null,
             status: 'DRAFT',
-            updatedAt: args.updatedAt,
+            updatedAt,
         }));
     }),
-    createAttachment: defineMutator(v.object({
-        attachment: draftAttachmentSchema,
-        id: marcoSchemas.string.required(),
-        updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
+    createAttachment: defineMutator(draftMutatorSchemas.createAttachment, async ({ tx, args: { id, attachment, updatedAt } }) => {
         await tx.mutate(zeroCRUD.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(zeroCRUD.draft.update({
-            id: args.id,
-            updatedAt: args.updatedAt,
+            draftId: id,
+            fileName: attachment.fileName,
+            id: attachment.id,
+            mimeType: attachment.mimeType,
+            status: attachment.status,
+            totalSize: attachment.totalSize,
         }));
+        await tx.mutate(zeroCRUD.draft.update({ id, updatedAt }));
     }),
     createDraft: defineMutator(draftModelSchema, async ({ tx, ctx: { userId }, args }) => {
         await tx.mutate(zeroCRUD.draft.insert({
@@ -118,25 +143,14 @@ export const draftMutators = {
             }));
         }
     }),
-    deleteAttachment: defineMutator(v.object({
-        attachmentId: marcoSchemas.string.required(),
-        id: marcoSchemas.string.required(),
-        updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
+    deleteAttachment: defineMutator(draftMutatorSchemas.deleteAttachment, async ({ tx, args: { id, attachmentId, updatedAt } }) => {
         await tx.mutate(zeroCRUD.draftAttachment.delete({
-            id: args.attachmentId,
-        }));
-        await tx.mutate(zeroCRUD.draft.update({
-            id: args.id,
-            updatedAt: args.updatedAt,
+            id: attachmentId,
         }));
+        await tx.mutate(zeroCRUD.draft.update({ id, updatedAt }));
     }),
-    deleteDraft: defineMutator(v.object({
-        id: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        await tx.mutate(zeroCRUD.draft.delete({
-            id: args.id,
-        }));
+    deleteDraft: defineMutator(draftMutatorSchemas.deleteDraft, async ({ tx, args: { id } }) => {
+        await tx.mutate(zeroCRUD.draft.delete({ id }));
     }),
     scheduleSend: defineMutator(draftScheduleSchema, async ({ tx, args }) => {
         if (args.kind === 'IMMEDIATE') {
@@ -156,60 +170,45 @@ export const draftMutators = {
             }));
         }
     }),
-    setContent: defineMutator(v.object({
-        id: marcoSchemas.string.required(),
-        patch: marcoSchemas.drafts.contentPatch.patch(),
-        updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
-        const draft = await tx.query.draft.where('id', args.id).one().run();
+    setContent: defineMutator(draftMutatorSchemas.setContent, async ({ tx, args: { id, patch, updatedAt } }) => {
+        const draft = await tx.query.draft.where('id', id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
         await tx.mutate(zeroCRUD.draft.update({
             body: {
                 ...draft.body,
-                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', args.patch),
+                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', patch),
             },
-            id: args.id,
-            updatedAt: args.updatedAt,
+            id,
+            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.query.draft.where('id', args.id).one().run();
+    setEnvelope: defineMutator(draftMutatorSchemas.setEnvelope, async ({ tx, args: { id, envelope, updatedAt } }) => {
+        const draft = await tx.query.draft.where('id', id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
         await tx.mutate(zeroCRUD.draft.update({
             body: {
-                bcc: args.envelope.bcc,
-                cc: args.envelope.cc,
+                bcc: envelope.bcc,
+                cc: envelope.cc,
                 content: draft.body.content,
-                to: args.envelope.to,
+                to: envelope.to,
             },
-            id: args.id,
-            subject: args.envelope.subject,
-            updatedAt: args.updatedAt,
+            id,
+            subject: envelope.subject,
+            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(draftMutatorSchemas.setFrom, async ({ tx, args: { id, accountId, aliasId, from, fromName, updatedAt } }) => {
         await tx.mutate(zeroCRUD.draft.update({
-            accountId: args.accountId,
-            fromAliasId: args.aliasId,
-            fromEmail: args.from,
-            fromName: args.fromName,
-            id: args.id,
-            updatedAt: args.updatedAt,
+            accountId,
+            fromAliasId: aliasId,
+            fromEmail: from,
+            fromName: fromName,
+            id,
+            updatedAt,
         }));
     }),
 };

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

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

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

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

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

@@ -1 +1 @@
-export * from './draftMutators';
+export { draftMutatorSchemas, draftMutators } from './draftMutators';