@marcoappio/marco-config 2.0.493 → 2.0.494

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

@@ -1,6 +1,7 @@
+import { defineMutator } from '@rocicorp/zero';
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../schemas';
-import { defineMutator } from '../../../zero/mutators/defineMutator';
+import { zeroCRUD } from '../../../zero/crud';
 const accountAliasSchema = v.object({
     emailAddress: marcoSchemas.string.email(),
     id: marcoSchemas.string.required(),
@@ -13,7 +14,7 @@ export const accountMutators = {
         emailAddress: marcoSchemas.string.email(),
         id: marcoSchemas.string.required(),
     }), async ({ tx, ctx: { userId }, args }) => {
-        await tx.mutate.account.insert({
+        await tx.mutate(zeroCRUD.account.insert({
             color: args.color,
             displayName: null,
             id: args.id,
@@ -22,60 +23,60 @@ export const accountMutators = {
             mailTotalCount: 0,
             primaryAliasId: args.aliasId,
             userId,
-        });
-        await tx.mutate.accountAlias.insert({
+        }));
+        await tx.mutate(zeroCRUD.accountAlias.insert({
             accountId: args.id,
             emailAddress: args.emailAddress,
             id: args.aliasId,
             isPrimary: true,
             name: null,
-        });
+        }));
     }),
     createAlias: defineMutator(v.object({
         accountId: marcoSchemas.string.required(),
         alias: accountAliasSchema,
     }), async ({ tx, args }) => {
-        await tx.mutate.accountAlias.insert({
+        await tx.mutate(zeroCRUD.accountAlias.insert({
             accountId: args.accountId,
             emailAddress: args.alias.emailAddress,
             id: args.alias.id,
             isPrimary: false,
             name: args.alias.name ?? null,
-        });
+        }));
     }),
     deleteAccount: defineMutator(v.object({
         id: marcoSchemas.string.required(),
     }), async ({ tx, args }) => {
-        await tx.mutate.account.delete({
+        await tx.mutate(zeroCRUD.account.delete({
             id: args.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.accountAlias.delete({
+        await tx.mutate(zeroCRUD.accountAlias.delete({
             id: args.aliasId,
-        });
+        }));
         if (alias?.isPrimary) {
             const remainingAliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
             if (remainingAliases.length > 0) {
                 const newPrimaryAlias = remainingAliases[0];
-                await tx.mutate.accountAlias.update({
+                await tx.mutate(zeroCRUD.accountAlias.update({
                     id: newPrimaryAlias.id,
                     isPrimary: true,
-                });
-                await tx.mutate.account.update({
+                }));
+                await tx.mutate(zeroCRUD.account.update({
                     id: args.accountId,
                     primaryAliasId: newPrimaryAlias.id,
-                });
+                }));
             }
             else {
-                await tx.mutate.account.update({
+                await tx.mutate(zeroCRUD.account.update({
                     id: args.accountId,
                     primaryAliasId: null,
-                });
+                }));
             }
         }
     }),
@@ -84,10 +85,10 @@ export const accountMutators = {
         aliasId: marcoSchemas.string.required(),
         displayName: marcoSchemas.string.nullable(),
     }), async ({ tx, args }) => {
-        await tx.mutate.accountAlias.update({
+        await tx.mutate(zeroCRUD.accountAlias.update({
             id: args.aliasId,
             name: args.displayName,
-        });
+        }));
     }),
     setAliasPrimary: defineMutator(v.object({
         accountId: marcoSchemas.string.required(),
@@ -95,43 +96,43 @@ export const accountMutators = {
     }), async ({ tx, args }) => {
         const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
         for (const alias of aliases) {
-            await tx.mutate.accountAlias.update({
+            await tx.mutate(zeroCRUD.accountAlias.update({
                 id: alias.id,
                 isPrimary: alias.id === args.aliasId,
-            });
+            }));
         }
-        await tx.mutate.account.update({
+        await tx.mutate(zeroCRUD.account.update({
             id: args.accountId,
             primaryAliasId: args.aliasId,
-        });
+        }));
     }),
     setConnectionConfigImapRaw: defineMutator(v.object({
         connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
         id: marcoSchemas.string.required(),
     }), async ({ tx, args }) => {
-        await tx.mutate.account.update({
+        await tx.mutate(zeroCRUD.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
-        });
+        }));
     }),
     setConnectionConfigOauth: defineMutator(v.object({
         connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
         id: marcoSchemas.string.required(),
     }), async ({ tx, args }) => {
-        await tx.mutate.account.update({
+        await tx.mutate(zeroCRUD.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
-        });
+        }));
     }),
     setSettings: defineMutator(v.object({
         color: v.optional(marcoSchemas.string.nullable()),
         displayName: v.optional(marcoSchemas.string.nullable()),
         id: marcoSchemas.string.required(),
     }), async ({ tx, args }) => {
-        await tx.mutate.account.update({
+        await tx.mutate(zeroCRUD.account.update({
             color: args.color ? args.color : undefined,
             displayName: args.displayName ? args.displayName : undefined,
             id: args.id,
-        });
+        }));
     }),
 };

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

@@ -5,7 +5,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 +28,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 +81,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 +92,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 +122,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 +141,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 +162,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 +179,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":"AAyDA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgOzB,CAAA"}

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

@@ -1,8 +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';
+import { zeroCRUD } from '../../../zero/crud';
 const draftStatusSchema = v.picklist(DRAFT_STATUSES);
 const draftTypeSchema = v.picklist(DRAFT_TYPES);
 const draftBodySchema = v.object({
@@ -59,33 +60,33 @@ export const draftMutators = {
         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: defineMutator(v.object({
         attachment: draftAttachmentSchema,
         id: marcoSchemas.string.required(),
         updatedAt: marcoSchemas.number.positiveInteger(),
     }), async ({ tx, args }) => {
-        await tx.mutate.draftAttachment.insert({
+        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: 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,16 +106,16 @@ 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({
@@ -122,37 +123,37 @@ export const draftMutators = {
         id: marcoSchemas.string.required(),
         updatedAt: marcoSchemas.number.positiveInteger(),
     }), async ({ tx, args }) => {
-        await tx.mutate.draftAttachment.delete({
+        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: defineMutator(v.object({
         id: marcoSchemas.string.required(),
     }), async ({ tx, args }) => {
-        await tx.mutate.draft.delete({
+        await tx.mutate(zeroCRUD.draft.delete({
             id: args.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({
@@ -164,14 +165,14 @@ export const draftMutators = {
         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: defineMutator(v.object({
         envelope: v.omit(draftBodySchema, ['content']),
@@ -182,7 +183,7 @@ export const draftMutators = {
         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,
@@ -192,7 +193,7 @@ export const draftMutators = {
             id: args.id,
             subject: args.envelope.subject,
             updatedAt: args.updatedAt,
-        });
+        }));
     }),
     setFrom: defineMutator(v.object({
         accountId: marcoSchemas.string.required(),
@@ -202,13 +203,13 @@ export const draftMutators = {
         id: marcoSchemas.string.required(),
         updatedAt: marcoSchemas.number.positiveInteger(),
     }), async ({ tx, args }) => {
-        await tx.mutate.draft.update({
+        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,4 +1,3 @@
-export { defineMutator, type MarcoZeroContext } from './defineMutator';
 export type { MarcoZeroMutators } 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,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACtE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,QAAQ,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,2 +1 @@
-export { defineMutator } from './defineMutator';
 export { mutators } from './mutators';