@marcoappio/marco-config 2.0.493 → 2.0.495

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;
@@ -5,7 +99,9 @@ export declare const draftMutators: {
     }, {
         id: string;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     createAttachment: import("@rocicorp/zero").MutatorDefinition<{
         attachment: {
             fileName: string;
@@ -26,7 +122,9 @@ export declare const draftMutators: {
         };
         id: string;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     createDraft: import("@rocicorp/zero").MutatorDefinition<{
         accountId: string;
         attachments: {
@@ -77,7 +175,9 @@ export declare const draftMutators: {
         status: "DRAFT" | "SEND_REQUESTED" | "SEND_CONFIRMED" | "SEND_FAILED";
         type: "NEW" | "REPLY" | "FORWARD";
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     deleteAttachment: import("@rocicorp/zero").MutatorDefinition<{
         attachmentId: string;
         id: string;
@@ -86,12 +186,16 @@ export declare const draftMutators: {
         attachmentId: string;
         id: string;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     deleteDraft: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
     }, {
         id: string;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     scheduleSend: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
         kind: "IMMEDIATE";
@@ -112,7 +216,9 @@ export declare const draftMutators: {
         kind: "SCHEDULED";
         scheduledFor: number;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setContent: import("@rocicorp/zero").MutatorDefinition<{
         id: string;
         patch: {
@@ -129,7 +235,9 @@ export declare const draftMutators: {
             value: string;
         }[];
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setEnvelope: import("@rocicorp/zero").MutatorDefinition<{
         envelope: {
             bcc: string[];
@@ -148,7 +256,9 @@ export declare const draftMutators: {
         };
         id: string;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
     setFrom: import("@rocicorp/zero").MutatorDefinition<{
         accountId: string;
         aliasId: string;
@@ -163,6 +273,8 @@ export declare const draftMutators: {
         fromName: string | null;
         id: string;
         updatedAt: number;
-    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    }, {
+        readonly userId: string;
+    }, unknown>;
 };
 //# sourceMappingURL=draftMutators.d.ts.map

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":"AAwDA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMzB,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

@@ -1,10 +1,9 @@
+import { defineMutator } from '@rocicorp/zero';
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../schemas';
 import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, MutationError } from '../../../types';
 import { stringPatch } from '../../../utils';
-import { defineMutator } from '../../../zero/mutators/defineMutator';
-const draftStatusSchema = v.picklist(DRAFT_STATUSES);
-const draftTypeSchema = v.picklist(DRAFT_TYPES);
+import { zeroCRUD } from '../../../zero/crud';
 const draftBodySchema = v.object({
     bcc: v.array(marcoSchemas.string.email()),
     cc: v.array(marcoSchemas.string.email()),
@@ -43,49 +42,76 @@ 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(),
+    }),
+    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(),
-    }), async ({ tx, args }) => {
-        const draft = await tx.query.draft.where('id', args.id).one().run();
+    }),
+};
+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);
         }
         if (draft.status === 'SEND_CONFIRMED') {
             throw new Error(MutationError.ALREADY_APPLIED);
         }
-        await tx.mutate.draft.update({
-            id: args.id,
+        await tx.mutate(zeroCRUD.draft.update({
+            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 }) => {
-        await tx.mutate.draftAttachment.insert({
-            draftId: args.id,
-            fileName: args.attachment.fileName,
-            id: args.attachment.id,
-            mimeType: args.attachment.mimeType,
-            status: args.attachment.status,
-            totalSize: args.attachment.totalSize,
-        });
-        await tx.mutate.draft.update({
-            id: args.id,
-            updatedAt: args.updatedAt,
-        });
+    createAttachment: defineMutator(draftMutatorSchemas.createAttachment, async ({ tx, args: { id, attachment, updatedAt } }) => {
+        await tx.mutate(zeroCRUD.draftAttachment.insert({
+            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.draft.insert({
+        await tx.mutate(zeroCRUD.draft.insert({
             accountId: args.accountId,
             body: {
                 bcc: args.body.bcc,
@@ -105,110 +131,84 @@ export const draftMutators = {
             type: args.type,
             updatedAt: args.updatedAt,
             userId,
-        });
+        }));
         for (const attachment of args.attachments) {
-            await tx.mutate.draftAttachment.insert({
+            await tx.mutate(zeroCRUD.draftAttachment.insert({
                 draftId: args.id,
                 fileName: attachment.fileName,
                 id: attachment.id,
                 mimeType: attachment.mimeType,
                 status: attachment.status,
                 totalSize: attachment.totalSize,
-            });
+            }));
         }
     }),
-    deleteAttachment: defineMutator(v.object({
-        attachmentId: marcoSchemas.string.required(),
-        id: marcoSchemas.string.required(),
-        updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
-        await tx.mutate.draftAttachment.delete({
-            id: args.attachmentId,
-        });
-        await tx.mutate.draft.update({
-            id: args.id,
-            updatedAt: args.updatedAt,
-        });
+    deleteAttachment: defineMutator(draftMutatorSchemas.deleteAttachment, async ({ tx, args: { id, attachmentId, updatedAt } }) => {
+        await tx.mutate(zeroCRUD.draftAttachment.delete({
+            id: attachmentId,
+        }));
+        await tx.mutate(zeroCRUD.draft.update({ id, updatedAt }));
     }),
-    deleteDraft: defineMutator(v.object({
-        id: marcoSchemas.string.required(),
-    }), async ({ tx, args }) => {
-        await tx.mutate.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') {
-            await tx.mutate.draft.update({
+            await tx.mutate(zeroCRUD.draft.update({
                 id: args.id,
                 scheduledFor: args.updatedAt + args.undoMs,
                 status: 'SEND_REQUESTED',
                 updatedAt: args.updatedAt,
-            });
+            }));
         }
         else {
-            await tx.mutate.draft.update({
+            await tx.mutate(zeroCRUD.draft.update({
                 id: args.id,
                 scheduledFor: args.scheduledFor,
                 status: 'SEND_REQUESTED',
                 updatedAt: args.updatedAt,
-            });
+            }));
         }
     }),
-    setContent: defineMutator(v.object({
-        id: marcoSchemas.string.required(),
-        patch: marcoSchemas.drafts.contentPatch.patch(),
-        updatedAt: marcoSchemas.number.positiveInteger(),
-    }), async ({ tx, args }) => {
-        const draft = await tx.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.draft.update({
+        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.draft.update({
+        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 }) => {
-        await tx.mutate.draft.update({
-            accountId: args.accountId,
-            fromAliasId: args.aliasId,
-            fromEmail: args.from,
-            fromName: args.fromName,
-            id: args.id,
-            updatedAt: args.updatedAt,
-        });
+    setFrom: defineMutator(draftMutatorSchemas.setFrom, async ({ tx, args: { id, accountId, aliasId, from, fromName, updatedAt } }) => {
+        await tx.mutate(zeroCRUD.draft.update({
+            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';