@marcoappio/marco-config 2.0.492 → 2.0.494

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

@@ -1,7 +1,58 @@
-import { MutationError } from '../../../types';
+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';
-export const createDraftMutators = (authData) => ({
-    cancelSend: async (tx, args) => {
+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()),
+    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 draftScheduleSchema = 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(),
+    }),
+]);
+const draftModelSchema = 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: draftStatusSchema,
+    type: draftTypeSchema,
+    updatedAt: marcoSchemas.number.positiveInteger(),
+});
+export const draftMutators = {
+    cancelSend: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -9,32 +60,33 @@ export const createDraftMutators = (authData) => ({
         if (draft.status === 'SEND_CONFIRMED') {
             throw new Error(MutationError.ALREADY_APPLIED);
         }
-        await tx.mutate.draft.update({
+        await tx.mutate(zeroCRUD.draft.update({
             id: args.id,
             scheduledFor: null,
             status: 'DRAFT',
             updatedAt: args.updatedAt,
-        });
-    },
-    createAttachment: async (tx, args) => {
-        await tx.mutate.draftAttachment.insert({
+        }));
+    }),
+    createAttachment: defineMutator(v.object({
+        attachment: draftAttachmentSchema,
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
+        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.draft.update({
+        }));
+        await tx.mutate(zeroCRUD.draft.update({
             id: args.id,
             updatedAt: args.updatedAt,
-        });
-    },
-    createDraft: async (tx, args) => {
-        if (!authData) {
-            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
-        }
-        await tx.mutate.draft.insert({
+        }));
+    }),
+    createDraft: defineMutator(draftModelSchema, async ({ tx, ctx: { userId }, args }) => {
+        await tx.mutate(zeroCRUD.draft.insert({
             accountId: args.accountId,
             body: {
                 bcc: args.body.bcc,
@@ -53,71 +105,85 @@ export const createDraftMutators = (authData) => ({
             subject: args.body.subject,
             type: args.type,
             updatedAt: args.updatedAt,
-            userId: authData.sub,
-        });
+            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: async (tx, args) => {
-        await tx.mutate.draftAttachment.delete({
+    }),
+    deleteAttachment: defineMutator(v.object({
+        attachmentId: marcoSchemas.string.required(),
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
+        await tx.mutate(zeroCRUD.draftAttachment.delete({
             id: args.attachmentId,
-        });
-        await tx.mutate.draft.update({
+        }));
+        await tx.mutate(zeroCRUD.draft.update({
             id: args.id,
             updatedAt: args.updatedAt,
-        });
-    },
-    deleteDraft: async (tx, args) => {
-        await tx.mutate.draft.delete({
+        }));
+    }),
+    deleteDraft: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+    }), async ({ tx, args }) => {
+        await tx.mutate(zeroCRUD.draft.delete({
             id: args.id,
-        });
-    },
-    scheduleSend: async (tx, args) => {
+        }));
+    }),
+    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: async (tx, args) => {
+    }),
+    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();
         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),
             },
             id: args.id,
             updatedAt: args.updatedAt,
-        });
-    },
-    setEnvelope: async (tx, args) => {
+        }));
+    }),
+    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();
         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,
@@ -127,16 +193,23 @@ export const createDraftMutators = (authData) => ({
             id: args.id,
             subject: args.envelope.subject,
             updatedAt: args.updatedAt,
-        });
-    },
-    setFrom: async (tx, args) => {
-        await tx.mutate.draft.update({
+        }));
+    }),
+    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(zeroCRUD.draft.update({
             accountId: args.accountId,
             fromAliasId: args.aliasId,
             fromEmail: args.from,
             fromName: args.fromName,
             id: args.id,
             updatedAt: args.updatedAt,
-        });
-    },
-});
+        }));
+    }),
+};

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

@@ -1,3 +1,3 @@
 export type { MarcoZeroMutators } from './mutators';
-export { createMutators, ZeroMutatorValidationError } from './mutators';
+export { mutators } from './mutators';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/zero/mutators/index.js

@@ -1 +1 @@
-export { createMutators, ZeroMutatorValidationError } from './mutators';
+export { mutators } from './mutators';