@marcoappio/marco-config 2.0.540 → 2.0.542

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

@@ -1 +0,0 @@
-{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../src/zero/mutators.ts"],"names":[],"mappings":"AASA,KAAK,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAqGjC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmjBnB,CAAA"}

package/dist/zero/mutators.js

@@ -1,560 +0,0 @@
-import { createBuilder, defineMutators, defineMutatorWithType } from '@rocicorp/zero';
-import { marcoConstants } from '../constants';
-import { stringPatch } from '../utils';
-import { threadsUtils } from '../utils/threads';
-import { mutatorSchemas } from '../zero/mutatorSchemas';
-import { schema } from '../zero/schema';
-const zql = createBuilder(schema);
-const defineMutator = defineMutatorWithType();
-const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
-const setSystemLabel = async (tx, builder, threadId, targetSpecialUse) => {
-    const thread = await tx.run(builder.thread.where('id', threadId).one());
-    if (thread) {
-        const [targetLabel, messages] = await Promise.all([
-            tx.run(builder.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one()),
-            tx.run(builder.threadMessage.where('threadId', threadId)),
-        ]);
-        if (targetLabel) {
-            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.run(builder.accountLabel.where('id', 'IN', [...labelIdsToRemove]));
-                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 mutators = defineMutators({
-    account: {
-        createAccount: defineMutator(mutatorSchemas.account.createAccount, async ({ tx, ctx, args }) => {
-            await tx.mutate.account.insert({
-                color: args.color,
-                displayName: null,
-                id: args.id,
-                imapConnectionStatus: 'AWAITING_CONNECTION',
-                mailProcessedCount: 0,
-                mailTotalCount: 0,
-                primaryAliasId: args.aliasId,
-                userId: ctx.userId,
-            });
-            await tx.mutate.accountAlias.insert({
-                accountId: args.id,
-                emailAddress: args.emailAddress,
-                id: args.aliasId,
-                isPrimary: true,
-                name: null,
-            });
-        }),
-        createAlias: defineMutator(mutatorSchemas.account.createAlias, async ({ tx, args }) => {
-            await tx.mutate.accountAlias.insert({
-                accountId: args.accountId,
-                emailAddress: args.alias.emailAddress,
-                id: args.alias.id,
-                isPrimary: false,
-                name: args.alias.name ?? null,
-            });
-        }),
-        deleteAccount: defineMutator(mutatorSchemas.account.deleteAccount, async ({ tx, args }) => {
-            await tx.mutate.account.delete({
-                id: args.id,
-            });
-        }),
-        deleteAlias: defineMutator(mutatorSchemas.account.deleteAlias, async ({ tx, args }) => {
-            const alias = await tx.run(zql.accountAlias.where('id', args.aliasId).one());
-            await tx.mutate.accountAlias.delete({
-                id: args.aliasId,
-            });
-            if (alias?.isPrimary) {
-                const remainingAliases = await tx.run(zql.accountAlias.where('accountId', args.accountId));
-                if (remainingAliases.length > 0) {
-                    const newPrimaryAlias = remainingAliases[0];
-                    await tx.mutate.accountAlias.update({
-                        id: newPrimaryAlias.id,
-                        isPrimary: true,
-                    });
-                    await tx.mutate.account.update({
-                        id: args.accountId,
-                        primaryAliasId: newPrimaryAlias.id,
-                    });
-                }
-                else {
-                    await tx.mutate.account.update({
-                        id: args.accountId,
-                        primaryAliasId: null,
-                    });
-                }
-            }
-        }),
-        setAliasName: defineMutator(mutatorSchemas.account.setAliasName, async ({ tx, args }) => {
-            await tx.mutate.accountAlias.update({
-                id: args.aliasId,
-                name: args.displayName,
-            });
-        }),
-        setAliasPrimary: defineMutator(mutatorSchemas.account.setAliasPrimary, async ({ tx, args }) => {
-            const aliases = await tx.run(zql.accountAlias.where('accountId', args.accountId));
-            for (const alias of aliases) {
-                await tx.mutate.accountAlias.update({
-                    id: alias.id,
-                    isPrimary: alias.id === args.aliasId,
-                });
-            }
-            await tx.mutate.account.update({
-                id: args.accountId,
-                primaryAliasId: args.aliasId,
-            });
-        }),
-        setConnectionConfigImapRaw: defineMutator(mutatorSchemas.account.setConnectionConfigImapRaw, async ({ tx, args }) => {
-            await tx.mutate.account.update({
-                id: args.id,
-                imapConnectionStatus: 'AWAITING_CONNECTION',
-            });
-        }),
-        setConnectionConfigOauth: defineMutator(mutatorSchemas.account.setConnectionConfigOauth, async ({ tx, args }) => {
-            await tx.mutate.account.update({
-                id: args.id,
-                imapConnectionStatus: 'AWAITING_CONNECTION',
-            });
-        }),
-        setSettings: defineMutator(mutatorSchemas.account.setSettings, async ({ tx, args }) => {
-            await tx.mutate.account.update({
-                color: args.color ? args.color : undefined,
-                displayName: args.displayName ? args.displayName : undefined,
-                id: args.id,
-            });
-        }),
-    },
-    draft: {
-        cancelSend: defineMutator(mutatorSchemas.draft.cancelSend, async ({ tx, args }) => {
-            const draft = await tx.run(zql.draft.where('id', args.id).one());
-            if (draft) {
-                if (draft.status !== 'SEND_CONFIRMED') {
-                    await tx.mutate.draft.update({
-                        id: args.id,
-                        scheduledFor: null,
-                        status: 'DRAFT',
-                        updatedAt: args.updatedAt,
-                    });
-                }
-            }
-        }),
-        createAttachment: defineMutator(mutatorSchemas.draft.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: defineMutator(mutatorSchemas.draft.createDraft, async ({ tx, ctx, args }) => {
-            await tx.mutate.draft.insert({
-                accountId: args.accountId,
-                body: {
-                    bcc: args.body.bcc,
-                    cc: args.body.cc,
-                    content: args.body.content,
-                    to: args.body.to,
-                },
-                error: args.error,
-                fromAliasId: null,
-                fromEmail: args.from,
-                fromName: args.fromName,
-                id: args.id,
-                referencedMessageId: args.referencedMessageId,
-                scheduledFor: args.scheduledFor,
-                status: args.status,
-                subject: args.body.subject,
-                type: args.type,
-                updatedAt: args.updatedAt,
-                userId: ctx.userId,
-            });
-            for (const attachment of args.attachments) {
-                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(mutatorSchemas.draft.deleteAttachment, async ({ tx, args }) => {
-            await tx.mutate.draftAttachment.delete({
-                id: args.attachmentId,
-            });
-            await tx.mutate.draft.update({
-                id: args.id,
-                updatedAt: args.updatedAt,
-            });
-        }),
-        deleteDraft: defineMutator(mutatorSchemas.draft.deleteDraft, async ({ tx, args }) => {
-            await tx.mutate.draft.delete({
-                id: args.id,
-            });
-        }),
-        scheduleSend: defineMutator(mutatorSchemas.draft.scheduleSend, async ({ tx, args }) => {
-            if (args.kind === 'IMMEDIATE') {
-                await tx.mutate.draft.update({
-                    id: args.id,
-                    scheduledFor: args.updatedAt + args.undoMs,
-                    status: 'SEND_REQUESTED',
-                    updatedAt: args.updatedAt,
-                });
-            }
-            else {
-                await tx.mutate.draft.update({
-                    id: args.id,
-                    scheduledFor: args.scheduledFor,
-                    status: 'SEND_REQUESTED',
-                    updatedAt: args.updatedAt,
-                });
-            }
-        }),
-        setContent: defineMutator(mutatorSchemas.draft.setContent, async ({ tx, args }) => {
-            const draft = await tx.run(zql.draft.where('id', args.id).one());
-            if (draft) {
-                await tx.mutate.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(mutatorSchemas.draft.setEnvelope, async ({ tx, args }) => {
-            const draft = await tx.run(zql.draft.where('id', args.id).one());
-            if (draft) {
-                await tx.mutate.draft.update({
-                    body: {
-                        bcc: args.envelope.bcc,
-                        cc: args.envelope.cc,
-                        content: draft.body.content,
-                        to: args.envelope.to,
-                    },
-                    id: args.id,
-                    subject: args.envelope.subject,
-                    updatedAt: args.updatedAt,
-                });
-            }
-        }),
-        setFrom: defineMutator(mutatorSchemas.draft.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,
-            });
-        }),
-    },
-    thread: {
-        addLabel: defineMutator(mutatorSchemas.thread.addLabel, async ({ tx, args }) => {
-            for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
-                const label = await tx.run(zql.accountLabel.where('accountId', accountId).where('path', args.labelPath).one());
-                if (label) {
-                    for (const threadId of threadIds) {
-                        const [thread, messages] = await Promise.all([
-                            tx.run(zql.thread.where('id', threadId).one()),
-                            tx.run(zql.threadMessage.where('threadId', threadId)),
-                        ]);
-                        if (thread) {
-                            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.run(zql.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one())));
-                            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: defineMutator(mutatorSchemas.thread.delete, async ({ tx, args }) => {
-            for (const [, { threadIds }] of Object.entries(args.accounts)) {
-                for (const threadId of threadIds) {
-                    const thread = await tx.run(zql.thread.where('id', threadId).one());
-                    if (thread) {
-                        if (thread.seen === false) {
-                            const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
-                            if (labelIds.length > 0) {
-                                const labels = await tx.run(zql.accountLabel.where('id', 'IN', labelIds));
-                                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: defineMutator(mutatorSchemas.thread.removeLabel, async ({ tx, args }) => {
-            for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
-                const label = await tx.run(zql.accountLabel.where('accountId', accountId).where('path', args.labelPath).one());
-                if (label) {
-                    for (const threadId of threadIds) {
-                        const [thread, messages] = await Promise.all([
-                            tx.run(zql.thread.where('id', threadId).one()),
-                            tx.run(zql.threadMessage.where('threadId', threadId)),
-                        ]);
-                        if (thread) {
-                            const currentLabelIds = new Set(threadsUtils.parseLabelIdList(thread.labelIdList));
-                            if (currentLabelIds.has(label.id)) {
-                                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: defineMutator(mutatorSchemas.thread.setArchive, async ({ tx, args }) => {
-            for (const [, { threadIds }] of Object.entries(args.accounts)) {
-                for (const threadId of threadIds) {
-                    await setSystemLabel(tx, zql, threadId, 'ARCHIVE');
-                }
-            }
-        }),
-        setFlagged: defineMutator(mutatorSchemas.thread.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(mutatorSchemas.thread.setInbox, async ({ tx, args }) => {
-            for (const [, { threadIds }] of Object.entries(args.accounts)) {
-                for (const threadId of threadIds) {
-                    await setSystemLabel(tx, zql, threadId, 'INBOX');
-                }
-            }
-        }),
-        setSeen: defineMutator(mutatorSchemas.thread.setSeen, async ({ tx, args }) => {
-            const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
-            const threads = await tx.run(zql.thread.where('id', 'IN', allThreadIds));
-            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.run(zql.accountLabel.where('id', 'IN', [...labelCounts.keys()]));
-                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: defineMutator(mutatorSchemas.thread.setSpam, async ({ tx, args }) => {
-            for (const [, { threadIds }] of Object.entries(args.accounts)) {
-                for (const threadId of threadIds) {
-                    await setSystemLabel(tx, zql, threadId, 'SPAM');
-                }
-            }
-        }),
-        setTrash: defineMutator(mutatorSchemas.thread.setTrash, async ({ tx, args }) => {
-            for (const [, { threadIds }] of Object.entries(args.accounts)) {
-                for (const threadId of threadIds) {
-                    await setSystemLabel(tx, zql, threadId, 'TRASH');
-                }
-            }
-        }),
-    },
-    user: {
-        createView: defineMutator(mutatorSchemas.user.createView, async ({ tx, args }) => {
-            const user = await tx.run(zql.user.where('id', args.id).one());
-            if (user) {
-                const currentViews = user.views ?? [];
-                const existingView = currentViews.find(x => x.id === args.view.id);
-                if (!existingView && currentViews.length < marcoConstants.user.views.maxViews) {
-                    await tx.mutate.user.update({
-                        id: args.id,
-                        views: [
-                            ...currentViews,
-                            {
-                                ...args.view,
-                                aliasEmails: [...new Set(args.view.aliasEmails)],
-                            },
-                        ],
-                    });
-                }
-            }
-        }),
-        deleteSettingsPushNotificationToken: defineMutator(mutatorSchemas.user.deleteSettingsPushNotificationToken, async ({ tx, args }) => {
-            await tx.mutate.userPushNotificationToken.delete({
-                id: args.id,
-            });
-        }),
-        deleteView: defineMutator(mutatorSchemas.user.deleteView, async ({ tx, args }) => {
-            const user = await tx.run(zql.user.where('id', args.id).one());
-            if (user) {
-                await tx.mutate.user.update({
-                    id: args.id,
-                    views: (user.views ?? []).filter(x => x.id !== args.viewId),
-                });
-            }
-        }),
-        setSettingsName: defineMutator(mutatorSchemas.user.setSettingsName, async ({ tx, args }) => {
-            await tx.mutate.user.update({
-                id: args.id,
-                name: args.name,
-            });
-        }),
-        setSettingsPushNotificationToken: defineMutator(mutatorSchemas.user.setSettingsPushNotificationToken, async ({ tx, args }) => {
-            const existing = await tx.run(zql.userPushNotificationToken.where('userId', args.id).where('token', args.pushNotificationToken.token).one());
-            if (!existing) {
-                await tx.mutate.userPushNotificationToken.insert({
-                    createdAt: args.pushNotificationToken.createdAt,
-                    id: args.pushNotificationToken.id,
-                    token: args.pushNotificationToken.token,
-                    userId: args.id,
-                });
-            }
-        }),
-        updateView: defineMutator(mutatorSchemas.user.updateView, async ({ tx, args }) => {
-            const user = await tx.run(zql.user.where('id', args.id).one());
-            if (user) {
-                const viewExists = (user.views ?? []).some(x => x.id === args.view.id);
-                if (viewExists) {
-                    const deduplicatedEmails = [...new Set(args.view.aliasEmails)];
-                    await tx.mutate.user.update({
-                        id: args.id,
-                        views: (user.views ?? []).map(x => x.id === args.view.id
-                            ? {
-                                ...args.view,
-                                aliasEmails: deduplicatedEmails,
-                            }
-                            : x),
-                    });
-                }
-            }
-        }),
-    },
-});

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

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

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

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