@marcoappio/marco-config 2.0.508 → 2.0.510

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

@@ -1,257 +0,0 @@
-import { MutationError } from '../../../types';
-import { threadsUtils } from '../../../utils/threads';
-const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
-export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
-    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.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);
-    }
-    const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-    const hasTarget = currentLabelIds.has(targetLabel.id);
-    const labelIdsToRemove = new Set(currentLabelIds);
-    labelIdsToRemove.delete(targetLabel.id);
-    const threadLabelDeletes = [];
-    for (const message of messages) {
-        for (const labelId of labelIdsToRemove) {
-            threadLabelDeletes.push(tx.mutate.threadLabel.delete({
-                accountId: thread.accountId,
-                labelId,
-                threadMessageId: message.id,
-            }));
-        }
-    }
-    await Promise.all([
-        ...threadLabelDeletes,
-        ...[...labelIdsToRemove].map(labelId => tx.mutate.threadByLabel.delete({ labelId, threadId })),
-    ]);
-    if (thread.seen === false && labelIdsToRemove.size > 0) {
-        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.threadLabel.insert({
-                accountId: thread.accountId,
-                labelId: targetLabel.id,
-                lastSyncedAt: 0,
-                threadId,
-                threadMessageId: message.id,
-                uid: -(baseTimestamp + i),
-                uidValidity: targetLabel.uidValidity ?? 0,
-            })),
-            tx.mutate.threadByLabel.insert({
-                labelId: targetLabel.id,
-                latestMessageDate: thread.latestMessageDate,
-                threadId,
-            }),
-            ...(thread.seen === false
-                ? [
-                    tx.mutate.accountLabel.update({
-                        id: targetLabel.id,
-                        unreadCount: (targetLabel.unreadCount ?? 0) + 1,
-                    }),
-                ]
-                : []),
-        ]);
-    }
-    await tx.mutate.thread.update({
-        id: threadId,
-        labelIdList: buildLabelIdList([targetLabel.id]),
-    });
-};
-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.query.thread.where('id', threadId).one().run(),
-                    tx.query.threadMessage.where('threadId', threadId).run(),
-                ]);
-                if (!thread) {
-                    throw new Error(MutationError.ENTITY_NOT_FOUND);
-                }
-                const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-                if (!currentLabelIds.has(label.id)) {
-                    await Promise.all([
-                        tx.mutate.threadByLabel.insert({
-                            labelId: label.id,
-                            latestMessageDate: thread.latestMessageDate,
-                            threadId,
-                        }),
-                        ...(thread.seen === false
-                            ? [
-                                tx.mutate.accountLabel.update({
-                                    id: label.id,
-                                    unreadCount: (label.unreadCount ?? 0) + 1,
-                                }),
-                            ]
-                            : []),
-                    ]);
-                }
-                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.threadLabel.insert({
-                        accountId,
-                        labelId: label.id,
-                        lastSyncedAt: 0,
-                        threadId,
-                        threadMessageId: x.id,
-                        uid: -(baseTimestamp + i),
-                        uidValidity: label.uidValidity ?? 0,
-                    })));
-                }
-                currentLabelIds.add(label.id);
-                await tx.mutate.thread.update({
-                    id: threadId,
-                    labelIdList: buildLabelIdList([...currentLabelIds]),
-                });
-            }
-        }
-    },
-    delete: async (tx, args) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
-            for (const threadId of threadIds) {
-                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.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.thread.delete({
-                        id: threadId,
-                    });
-                }
-            }
-        }
-    },
-    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.query.thread.where('id', threadId).one().run(),
-                    tx.query.threadMessage.where('threadId', threadId).run(),
-                ]);
-                if (!thread) {
-                    throw new Error(MutationError.ENTITY_NOT_FOUND);
-                }
-                const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-                if (!currentLabelIds.has(label.id)) {
-                    throw new Error(MutationError.ENTITY_NOT_FOUND);
-                }
-                currentLabelIds.delete(label.id);
-                await Promise.all([
-                    ...messages.map(x => tx.mutate.threadLabel.delete({
-                        accountId,
-                        labelId: label.id,
-                        threadMessageId: x.id,
-                    })),
-                    tx.mutate.threadByLabel.delete({
-                        labelId: label.id,
-                        threadId,
-                    }),
-                    ...(thread.seen === false
-                        ? [
-                            tx.mutate.accountLabel.update({
-                                id: label.id,
-                                unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
-                            }),
-                        ]
-                        : []),
-                    tx.mutate.thread.update({
-                        id: threadId,
-                        labelIdList: buildLabelIdList([...currentLabelIds]),
-                    }),
-                ]);
-            }
-        }
-    },
-    setArchive: async (tx, args) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
-            for (const threadId of threadIds) {
-                await setSystemLabel(tx, threadId, 'ARCHIVE');
-            }
-        }
-    },
-    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: async (tx, args) => {
-        for (const [, { threadIds }] of Object.entries(args.accounts)) {
-            for (const threadId of threadIds) {
-                await setSystemLabel(tx, threadId, 'INBOX');
-            }
-        }
-    },
-    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 !== 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.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.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.thread.update({
-            id: threadId,
-            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: 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

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

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

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