@marcoappio/marco-config 2.0.504 → 2.0.505

package/dist/zero/mutators/threadMutators/threadMutators.js

@@ -1,46 +1,14 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../schemas';
 import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
-import { zeroCRUD } from '../../../zero/crud';
-import { defineMutator } from '../../../zero/mutators/typedMutator';
-import { z } from '../../../zero/queries/z';
 const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
-const accountsSchema = v.record(marcoSchemas.string.required(), v.object({
-    threadIds: v.array(marcoSchemas.string.required()),
-}));
-const baseThreadSchema = v.object({
-    accounts: accountsSchema,
-});
-const threadChangeLabelSchema = v.object({
-    accounts: accountsSchema,
-    labelPath: marcoSchemas.string.required(),
-});
-export const threadMutatorSchemas = {
-    addLabel: threadChangeLabelSchema,
-    delete: baseThreadSchema,
-    removeLabel: threadChangeLabelSchema,
-    setArchive: baseThreadSchema,
-    setFlagged: v.object({
-        accounts: accountsSchema,
-        flagged: v.nonOptional(v.boolean()),
-    }),
-    setInbox: baseThreadSchema,
-    setSeen: v.object({
-        accounts: accountsSchema,
-        seen: v.boolean(),
-    }),
-    setSpam: baseThreadSchema,
-    setTrash: baseThreadSchema,
-};
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
-    const thread = await tx.run(z.thread.where('id', threadId).one());
+    const thread = await tx.query.thread.where('id', threadId).one().run();
     if (!thread) {
         throw new Error(MutationError.ENTITY_NOT_FOUND);
     }
     const [targetLabel, messages] = await Promise.all([
-        tx.run(z.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one()),
-        tx.run(z.threadMessage.where('threadId', threadId)),
+        tx.query.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one().run(),
+        tx.query.threadMessage.where('threadId', threadId).run(),
     ]);
     if (!targetLabel) {
         throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -52,28 +20,28 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const threadLabelDeletes = [];
     for (const message of messages) {
         for (const labelId of labelIdsToRemove) {
-            threadLabelDeletes.push(tx.mutate(zeroCRUD.threadLabel.delete({
+            threadLabelDeletes.push(tx.mutate.threadLabel.delete({
                 accountId: thread.accountId,
                 labelId,
                 threadMessageId: message.id,
-            })));
+            }));
         }
     }
     await Promise.all([
         ...threadLabelDeletes,
-        ...[...labelIdsToRemove].map(labelId => tx.mutate(zeroCRUD.threadByLabel.delete({ labelId, threadId }))),
+        ...[...labelIdsToRemove].map(labelId => tx.mutate.threadByLabel.delete({ labelId, threadId })),
     ]);
     if (thread.seen === false && labelIdsToRemove.size > 0) {
-        const labelsToUpdate = await tx.run(z.accountLabel.where('id', 'IN', [...labelIdsToRemove]));
-        await Promise.all(labelsToUpdate.map(label => tx.mutate(zeroCRUD.accountLabel.update({
+        const labelsToUpdate = await tx.query.accountLabel.where('id', 'IN', [...labelIdsToRemove]).run();
+        await Promise.all(labelsToUpdate.map(label => tx.mutate.accountLabel.update({
             id: label.id,
             unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-        }))));
+        })));
     }
     if (!hasTarget) {
         const baseTimestamp = Date.now();
         await Promise.all([
-            ...messages.map((message, i) => tx.mutate(zeroCRUD.threadLabel.insert({
+            ...messages.map((message, i) => tx.mutate.threadLabel.insert({
                 accountId: thread.accountId,
                 labelId: targetLabel.id,
                 lastSyncedAt: 0,
@@ -81,38 +49,38 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
                 threadMessageId: message.id,
                 uid: -(baseTimestamp + i),
                 uidValidity: targetLabel.uidValidity ?? 0,
-            }))),
-            tx.mutate(zeroCRUD.threadByLabel.insert({
+            })),
+            tx.mutate.threadByLabel.insert({
                 labelId: targetLabel.id,
                 latestMessageDate: thread.latestMessageDate,
                 threadId,
-            })),
+            }),
             ...(thread.seen === false
                 ? [
-                    tx.mutate(zeroCRUD.accountLabel.update({
+                    tx.mutate.accountLabel.update({
                         id: targetLabel.id,
                         unreadCount: (targetLabel.unreadCount ?? 0) + 1,
-                    })),
+                    }),
                 ]
                 : []),
         ]);
     }
-    await tx.mutate(zeroCRUD.thread.update({
+    await tx.mutate.thread.update({
         id: threadId,
         labelIdList: buildLabelIdList([targetLabel.id]),
-    }));
+    });
 };
-export const threadMutators = {
-    addLabel: defineMutator(threadMutatorSchemas.addLabel, async ({ tx, args: { accounts, labelPath } }) => {
-        for (const [accountId, { threadIds }] of Object.entries(accounts)) {
-            const label = await tx.run(z.accountLabel.where('accountId', accountId).where('path', labelPath).one());
+export const createThreadMutators = (_authData) => ({
+    addLabel: async (tx, args) => {
+        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             for (const threadId of threadIds) {
                 const [thread, messages] = await Promise.all([
-                    tx.run(z.thread.where('id', threadId).one()),
-                    tx.run(z.threadMessage.where('threadId', threadId)),
+                    tx.query.thread.where('id', threadId).one().run(),
+                    tx.query.threadMessage.where('threadId', threadId).run(),
                 ]);
                 if (!thread) {
                     throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -120,26 +88,26 @@ export const threadMutators = {
                 const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
                 if (!currentLabelIds.has(label.id)) {
                     await Promise.all([
-                        tx.mutate(zeroCRUD.threadByLabel.insert({
+                        tx.mutate.threadByLabel.insert({
                             labelId: label.id,
                             latestMessageDate: thread.latestMessageDate,
                             threadId,
-                        })),
+                        }),
                         ...(thread.seen === false
                             ? [
-                                tx.mutate(zeroCRUD.accountLabel.update({
+                                tx.mutate.accountLabel.update({
                                     id: label.id,
                                     unreadCount: (label.unreadCount ?? 0) + 1,
-                                })),
+                                }),
                             ]
                             : []),
                     ]);
                 }
-                const existingChecks = await Promise.all(messages.map(x => tx.run(z.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one())));
+                const existingChecks = await Promise.all(messages.map(x => tx.query.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one().run()));
                 const messagesToInsert = messages.filter((_, i) => !existingChecks[i]);
                 const baseTimestamp = Date.now();
                 if (messagesToInsert.length > 0) {
-                    await Promise.all(messagesToInsert.map((x, i) => tx.mutate(zeroCRUD.threadLabel.insert({
+                    await Promise.all(messagesToInsert.map((x, i) => tx.mutate.threadLabel.insert({
                         accountId,
                         labelId: label.id,
                         lastSyncedAt: 0,
@@ -147,48 +115,48 @@ export const threadMutators = {
                         threadMessageId: x.id,
                         uid: -(baseTimestamp + i),
                         uidValidity: label.uidValidity ?? 0,
-                    }))));
+                    })));
                 }
                 currentLabelIds.add(label.id);
-                await tx.mutate(zeroCRUD.thread.update({
+                await tx.mutate.thread.update({
                     id: threadId,
                     labelIdList: buildLabelIdList([...currentLabelIds]),
-                }));
+                });
             }
         }
-    }),
-    delete: defineMutator(threadMutatorSchemas.delete, async ({ tx, args: { accounts } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
+    },
+    delete: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
-                const thread = await tx.run(z.thread.where('id', threadId).one());
+                const thread = await tx.query.thread.where('id', threadId).one().run();
                 if (thread) {
                     if (thread.seen === false) {
                         const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
                         if (labelIds.length > 0) {
-                            const labels = await tx.run(z.accountLabel.where('id', 'IN', labelIds));
-                            await Promise.all(labels.map(x => tx.mutate(zeroCRUD.accountLabel.update({
+                            const labels = await tx.query.accountLabel.where('id', 'IN', labelIds).run();
+                            await Promise.all(labels.map(x => tx.mutate.accountLabel.update({
                                 id: x.id,
                                 unreadCount: Math.max(0, (x.unreadCount ?? 0) - 1),
-                            }))));
+                            })));
                         }
                     }
-                    await tx.mutate(zeroCRUD.thread.delete({
+                    await tx.mutate.thread.delete({
                         id: threadId,
-                    }));
+                    });
                 }
             }
         }
-    }),
-    removeLabel: defineMutator(threadMutatorSchemas.removeLabel, async ({ tx, args: { accounts, labelPath } }) => {
-        for (const [accountId, { threadIds }] of Object.entries(accounts)) {
-            const label = await tx.run(z.accountLabel.where('accountId', accountId).where('path', labelPath).one());
+    },
+    removeLabel: async (tx, args) => {
+        for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
+            const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             for (const threadId of threadIds) {
                 const [thread, messages] = await Promise.all([
-                    tx.run(z.thread.where('id', threadId).one()),
-                    tx.run(z.threadMessage.where('threadId', threadId)),
+                    tx.query.thread.where('id', threadId).one().run(),
+                    tx.query.threadMessage.where('threadId', threadId).run(),
                 ]);
                 if (!thread) {
                     throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -199,91 +167,91 @@ export const threadMutators = {
                 }
                 currentLabelIds.delete(label.id);
                 await Promise.all([
-                    ...messages.map(x => tx.mutate(zeroCRUD.threadLabel.delete({
+                    ...messages.map(x => tx.mutate.threadLabel.delete({
                         accountId,
                         labelId: label.id,
                         threadMessageId: x.id,
-                    }))),
-                    tx.mutate(zeroCRUD.threadByLabel.delete({
+                    })),
+                    tx.mutate.threadByLabel.delete({
                         labelId: label.id,
                         threadId,
-                    })),
+                    }),
                     ...(thread.seen === false
                         ? [
-                            tx.mutate(zeroCRUD.accountLabel.update({
+                            tx.mutate.accountLabel.update({
                                 id: label.id,
                                 unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-                            })),
+                            }),
                         ]
                         : []),
-                    tx.mutate(zeroCRUD.thread.update({
+                    tx.mutate.thread.update({
                         id: threadId,
                         labelIdList: buildLabelIdList([...currentLabelIds]),
-                    })),
+                    }),
                 ]);
             }
         }
-    }),
-    setArchive: defineMutator(threadMutatorSchemas.setArchive, async ({ tx, args: { accounts } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
+    },
+    setArchive: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'ARCHIVE');
             }
         }
-    }),
-    setFlagged: defineMutator(threadMutatorSchemas.setFlagged, async ({ tx, args: { accounts, flagged } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
-            await Promise.all(threadIds.map(threadId => tx.mutate(zeroCRUD.thread.update({
-                flagged,
+    },
+    setFlagged: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
+            await Promise.all(threadIds.map(threadId => tx.mutate.thread.update({
+                flagged: args.flagged,
                 id: threadId,
-            }))));
+            })));
         }
-    }),
-    setInbox: defineMutator(threadMutatorSchemas.setInbox, async ({ tx, args: { accounts } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
+    },
+    setInbox: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'INBOX');
             }
         }
-    }),
-    setSeen: defineMutator(threadMutatorSchemas.setSeen, async ({ tx, args: { accounts, seen } }) => {
-        const allThreadIds = Object.values(accounts).flatMap(x => x.threadIds);
-        const threads = await tx.run(z.thread.where('id', 'IN', allThreadIds));
+    },
+    setSeen: async (tx, args) => {
+        const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
+        const threads = await tx.query.thread.where('id', 'IN', allThreadIds).run();
         const labelCounts = new Map();
         for (const thread of threads) {
-            if (thread.seen !== seen) {
+            if (thread.seen !== args.seen) {
                 for (const labelId of threadsUtils.parseLabelIdList(thread.labelIdList)) {
                     labelCounts.set(labelId, (labelCounts.get(labelId) ?? 0) + 1);
                 }
             }
         }
         if (labelCounts.size > 0) {
-            const labels = await tx.run(z.accountLabel.where('id', 'IN', [...labelCounts.keys()]));
-            const delta = seen ? -1 : 1;
+            const labels = await tx.query.accountLabel.where('id', 'IN', [...labelCounts.keys()]).run();
+            const delta = args.seen ? -1 : 1;
             await Promise.all(labels
                 .filter(x => labelCounts.has(x.id))
-                .map(x => tx.mutate(zeroCRUD.accountLabel.update({
+                .map(x => tx.mutate.accountLabel.update({
                 id: x.id,
                 unreadCount: Math.max(0, (x.unreadCount ?? 0) + delta * (labelCounts.get(x.id) ?? 0)),
-            }))));
+            })));
         }
-        await Promise.all(allThreadIds.map(threadId => tx.mutate(zeroCRUD.thread.update({
+        await Promise.all(allThreadIds.map(threadId => tx.mutate.thread.update({
             id: threadId,
-            seen,
-        }))));
-    }),
-    setSpam: defineMutator(threadMutatorSchemas.setSpam, async ({ tx, args: { accounts } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
+            seen: args.seen,
+        })));
+    },
+    setSpam: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'SPAM');
             }
         }
-    }),
-    setTrash: defineMutator(threadMutatorSchemas.setTrash, async ({ tx, args: { accounts } }) => {
-        for (const [, { threadIds }] of Object.entries(accounts)) {
+    },
+    setTrash: async (tx, args) => {
+        for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'TRASH');
             }
         }
-    }),
-};
+    },
+});

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

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

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

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