@marcoappio/marco-config 2.0.504 → 2.0.505

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

@@ -1,306 +1,4 @@
-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>;
-    createDraft: v.ObjectSchema<{
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly attachments: v.ArraySchema<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>, undefined>;
-        readonly body: 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>;
-        readonly error: v.NullableSchema<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 referencedMessageId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-        readonly status: v.PicklistSchema<readonly ["DRAFT", "SEND_REQUESTED", "SEND_CONFIRMED", "SEND_FAILED"], undefined>;
-        readonly type: v.PicklistSchema<readonly ["NEW", "REPLY", "FORWARD"], 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;
-        updatedAt: number;
-    }, {
-        id: string;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    createAttachment: import("@rocicorp/zero").MutatorDefinition<{
-        attachment: {
-            fileName: string;
-            id: string;
-            mimeType: string;
-            status: "PENDING" | "COMPLETE" | "FAILED";
-            totalSize: number;
-        };
-        id: string;
-        updatedAt: number;
-    }, {
-        attachment: {
-            fileName: string;
-            id: string;
-            mimeType: string;
-            status: "PENDING" | "COMPLETE" | "FAILED";
-            totalSize: number;
-        };
-        id: string;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    createDraft: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        attachments: {
-            fileName: string;
-            id: string;
-            mimeType: string;
-            status: "PENDING" | "COMPLETE" | "FAILED";
-            totalSize: number;
-        }[];
-        body: {
-            bcc: string[];
-            cc: string[];
-            content: string;
-            subject: string | null;
-            to: string[];
-        };
-        error: string | null;
-        from: string;
-        fromName: string | null;
-        id: string;
-        referencedMessageId: string | null;
-        scheduledFor: number | null;
-        status: "DRAFT" | "SEND_REQUESTED" | "SEND_CONFIRMED" | "SEND_FAILED";
-        type: "NEW" | "REPLY" | "FORWARD";
-        updatedAt: number;
-    }, {
-        accountId: string;
-        attachments: {
-            fileName: string;
-            id: string;
-            mimeType: string;
-            status: "PENDING" | "COMPLETE" | "FAILED";
-            totalSize: number;
-        }[];
-        body: {
-            bcc: string[];
-            cc: string[];
-            content: string;
-            subject: string | null;
-            to: string[];
-        };
-        error: string | null;
-        from: string;
-        fromName: string | null;
-        id: string;
-        referencedMessageId: string | null;
-        scheduledFor: number | null;
-        status: "DRAFT" | "SEND_REQUESTED" | "SEND_CONFIRMED" | "SEND_FAILED";
-        type: "NEW" | "REPLY" | "FORWARD";
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    deleteAttachment: import("@rocicorp/zero").MutatorDefinition<{
-        attachmentId: string;
-        id: string;
-        updatedAt: number;
-    }, {
-        attachmentId: string;
-        id: string;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    deleteDraft: import("@rocicorp/zero").MutatorDefinition<{
-        id: string;
-    }, {
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    scheduleSend: import("@rocicorp/zero").MutatorDefinition<{
-        id: string;
-        kind: "IMMEDIATE";
-        undoMs: number;
-        updatedAt: number;
-    } | {
-        id: string;
-        kind: "SCHEDULED";
-        scheduledFor: number;
-        updatedAt: number;
-    }, {
-        id: string;
-        kind: "IMMEDIATE";
-        undoMs: number;
-        updatedAt: number;
-    } | {
-        id: string;
-        kind: "SCHEDULED";
-        scheduledFor: number;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setContent: import("@rocicorp/zero").MutatorDefinition<{
-        id: string;
-        patch: {
-            index: number;
-            type: "INSERTION" | "DELETION";
-            value: string;
-        }[];
-        updatedAt: number;
-    }, {
-        id: string;
-        patch: {
-            index: number;
-            type: "INSERTION" | "DELETION";
-            value: string;
-        }[];
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setEnvelope: import("@rocicorp/zero").MutatorDefinition<{
-        envelope: {
-            bcc: string[];
-            cc: string[];
-            to: string[];
-            subject: string | null;
-        };
-        id: string;
-        updatedAt: number;
-    }, {
-        envelope: {
-            bcc: string[];
-            cc: string[];
-            to: string[];
-            subject: string | null;
-        };
-        id: string;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setFrom: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        aliasId: string;
-        from: string;
-        fromName: string | null;
-        id: string;
-        updatedAt: number;
-    }, {
-        accountId: string;
-        aliasId: string;
-        from: string;
-        fromName: string | null;
-        id: string;
-        updatedAt: number;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-};
+import { type AuthData, type HandlerMap } from '../../../types';
+import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
+export declare const createDraftMutators: (authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["draft"]>;
 //# 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":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC/B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKzB,CAAA"}
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,mBAAmB,aAAc,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAwJzG,CAAA"}

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

@@ -1,119 +1,40 @@
-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 { zeroCRUD } from '../../../zero/crud';
-import { z } from '../../../zero/queries/z';
-import { defineMutator } from '../typedMutator';
-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: v.picklist(DRAFT_STATUSES),
-    type: v.picklist(DRAFT_TYPES),
-    updatedAt: marcoSchemas.number.positiveInteger(),
-});
-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(),
-    }),
-    createDraft: draftModelSchema,
-    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(),
-    }),
-};
-export const draftMutators = {
-    cancelSend: defineMutator(draftMutatorSchemas.cancelSend, async ({ tx, args: { id, updatedAt } }) => {
-        const draft = await tx.run(z.draft.where('id', id).one());
+export const createDraftMutators = (authData) => ({
+    cancelSend: async (tx, args) => {
+        const draft = await tx.query.draft.where('id', args.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(zeroCRUD.draft.update({
-            id,
+        await tx.mutate.draft.update({
+            id: args.id,
             scheduledFor: null,
             status: 'DRAFT',
-            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(draftMutatorSchemas.createDraft, async ({ tx, ctx: { userId }, args }) => {
-        await tx.mutate(zeroCRUD.draft.insert({
+            updatedAt: args.updatedAt,
+        });
+    },
+    createAttachment: 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,
+        });
+    },
+    createDraft: async (tx, args) => {
+        if (!authData) {
+            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
+        }
+        await tx.mutate.draft.insert({
             accountId: args.accountId,
             body: {
                 bcc: args.body.bcc,
@@ -132,85 +53,90 @@ export const draftMutators = {
             subject: args.body.subject,
             type: args.type,
             updatedAt: args.updatedAt,
-            userId,
-        }));
+            userId: authData.sub,
+        });
         for (const attachment of args.attachments) {
-            await tx.mutate(zeroCRUD.draftAttachment.insert({
+            await tx.mutate.draftAttachment.insert({
                 draftId: args.id,
                 fileName: attachment.fileName,
                 id: attachment.id,
                 mimeType: attachment.mimeType,
                 status: attachment.status,
                 totalSize: attachment.totalSize,
-            }));
+            });
         }
-    }),
-    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(draftMutatorSchemas.deleteDraft, async ({ tx, args: { id } }) => {
-        await tx.mutate(zeroCRUD.draft.delete({ id }));
-    }),
-    scheduleSend: defineMutator(draftScheduleSchema, async ({ tx, args }) => {
+    },
+    deleteAttachment: async (tx, args) => {
+        await tx.mutate.draftAttachment.delete({
+            id: args.attachmentId,
+        });
+        await tx.mutate.draft.update({
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+    },
+    deleteDraft: async (tx, args) => {
+        await tx.mutate.draft.delete({
+            id: args.id,
+        });
+    },
+    scheduleSend: async (tx, args) => {
         if (args.kind === 'IMMEDIATE') {
-            await tx.mutate(zeroCRUD.draft.update({
+            await tx.mutate.draft.update({
                 id: args.id,
                 scheduledFor: args.updatedAt + args.undoMs,
                 status: 'SEND_REQUESTED',
                 updatedAt: args.updatedAt,
-            }));
+            });
         }
         else {
-            await tx.mutate(zeroCRUD.draft.update({
+            await tx.mutate.draft.update({
                 id: args.id,
                 scheduledFor: args.scheduledFor,
                 status: 'SEND_REQUESTED',
                 updatedAt: args.updatedAt,
-            }));
+            });
         }
-    }),
-    setContent: defineMutator(draftMutatorSchemas.setContent, async ({ tx, args: { id, patch, updatedAt } }) => {
-        const draft = await tx.run(z.draft.where('id', id).one());
+    },
+    setContent: 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(zeroCRUD.draft.update({
+        await tx.mutate.draft.update({
             body: {
                 ...draft.body,
-                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', patch),
+                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', args.patch),
             },
-            id,
-            updatedAt,
-        }));
-    }),
-    setEnvelope: defineMutator(draftMutatorSchemas.setEnvelope, async ({ tx, args: { id, envelope, updatedAt } }) => {
-        const draft = await tx.run(z.draft.where('id', id).one());
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+    },
+    setEnvelope: 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(zeroCRUD.draft.update({
+        await tx.mutate.draft.update({
             body: {
-                bcc: envelope.bcc,
-                cc: envelope.cc,
+                bcc: args.envelope.bcc,
+                cc: args.envelope.cc,
                 content: draft.body.content,
-                to: envelope.to,
+                to: args.envelope.to,
             },
-            id,
-            subject: envelope.subject,
-            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,
-        }));
-    }),
-};
+            id: args.id,
+            subject: args.envelope.subject,
+            updatedAt: args.updatedAt,
+        });
+    },
+    setFrom: 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,
+        });
+    },
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=draftMutators.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draftMutators.test.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.test.ts"],"names":[],"mappings":""}