@marcoappio/marco-config 2.0.427 → 2.0.428

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

@@ -0,0 +1,465 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createMutators } from '../mutators';
+describe('threadMutators', () => {
+    describe('addLabel', () => {
+        it('adds label to thread', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const labelRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-label-id-1',
+                path: 'Work',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => labelRecord);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereLabelPath = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereLabelPath }));
+            const runExisting = mock(async () => null);
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabelId = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabelId }));
+            const threadLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.addLabel(transaction, {
+                labelPath: 'Work',
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith({
+                labelId: 'test-label-id-1',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('delete', () => {
+        it('deletes threads', async () => {
+            const threadDelete = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    thread: {
+                        delete: threadDelete,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.thread.delete(transaction, {
+                threadIds: ['test-thread-id-1', 'test-thread-id-2'],
+            });
+            expect(threadDelete).toHaveBeenCalledTimes(2);
+            expect(threadDelete).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+            });
+            expect(threadDelete).toHaveBeenCalledWith({
+                id: 'test-thread-id-2',
+            });
+        });
+    });
+    describe('removeLabel', () => {
+        it('removes label from thread', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const labelRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-label-id-1',
+                path: 'Work',
+            };
+            const existingRecord = {
+                labelId: 'test-label-id-1',
+                threadId: 'test-thread-id-1',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => labelRecord);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereLabelPath = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereLabelPath }));
+            const runExisting = mock(async () => existingRecord);
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabelId = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabelId }));
+            const threadLabelDelete = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.removeLabel(transaction, {
+                labelPath: 'Work',
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                labelId: 'test-label-id-1',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('requestAttachmentDownload', () => {
+        it('requests attachment download', async () => {
+            const attachmentRecord = {
+                id: 'test-attachment-id-1',
+                status: 'NOT_DOWNLOADED',
+            };
+            const run = mock(async () => attachmentRecord);
+            const one = mock(() => ({ run }));
+            const where = mock(() => ({ one }));
+            const attachmentUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadMessageAttachment: {
+                        update: attachmentUpdate,
+                    },
+                },
+                query: {
+                    threadMessageAttachment: {
+                        where,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.requestAttachmentDownload(transaction, {
+                attachmentId: 'test-attachment-id-1',
+                threadId: 'test-thread-id-1',
+            });
+            expect(attachmentUpdate).toHaveBeenCalledWith({
+                id: 'test-attachment-id-1',
+                status: 'DOWNLOAD_REQUESTED',
+            });
+        });
+    });
+    describe('setArchive', () => {
+        it('archives thread', async () => {
+            let labelQueryCount = 0;
+            let threadLabelQueryCount = 0;
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const inboxLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-inbox-label-id',
+                specialUse: 'INBOX',
+            };
+            const archiveLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-archive-label-id',
+                specialUse: 'ARCHIVE',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => {
+                const result = labelQueryCount === 0 ? inboxLabel : archiveLabel;
+                labelQueryCount++;
+                return result;
+            });
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runExisting = mock(async () => {
+                const result = threadLabelQueryCount === 0 ? { labelId: 'test-inbox-label-id' } : null;
+                threadLabelQueryCount++;
+                return result;
+            });
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabel = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const threadLabelDelete = mock(async () => { });
+            const threadLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setArchive(transaction, {
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                labelId: 'test-inbox-label-id',
+                threadId: 'test-thread-id-1',
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith({
+                labelId: 'test-archive-label-id',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('setFlagged', () => {
+        it('sets thread flagged status', async () => {
+            const threadUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.thread.setFlagged(transaction, {
+                flagged: true,
+                threadId: 'test-thread-id-1',
+            });
+            expect(threadUpdate).toHaveBeenCalledWith({
+                flagged: true,
+                id: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('setInbox', () => {
+        it('moves thread to inbox', async () => {
+            let labelQueryCount = 0;
+            let threadLabelQueryCount = 0;
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const inboxLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-inbox-label-id',
+                specialUse: 'INBOX',
+            };
+            const archiveLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-archive-label-id',
+                specialUse: 'ARCHIVE',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => {
+                const result = labelQueryCount === 0 ? inboxLabel : archiveLabel;
+                labelQueryCount++;
+                return result;
+            });
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runExisting = mock(async () => {
+                const result = threadLabelQueryCount === 0 ? { labelId: 'test-archive-label-id' } : null;
+                threadLabelQueryCount++;
+                return result;
+            });
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabel = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const threadLabelDelete = mock(async () => { });
+            const threadLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setInbox(transaction, {
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                labelId: 'test-archive-label-id',
+                threadId: 'test-thread-id-1',
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith({
+                labelId: 'test-inbox-label-id',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('setSeen', () => {
+        it('sets thread seen status', async () => {
+            const threadUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSeen(transaction, {
+                seen: true,
+                threadIds: ['test-thread-id-1', 'test-thread-id-2'],
+            });
+            expect(threadUpdate).toHaveBeenCalledTimes(2);
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                seen: true,
+            });
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-2',
+                seen: true,
+            });
+        });
+    });
+    describe('setSpam', () => {
+        it('marks thread as spam', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const spamLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-spam-label-id',
+                specialUse: 'SPAM',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runSpam = mock(async () => spamLabel);
+            const oneLabel = mock(() => ({ run: runSpam }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runExisting = mock(async () => null);
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabel = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const threadLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSpam(transaction, {
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith({
+                labelId: 'test-spam-label-id',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('setTrash', () => {
+        it('moves thread to trash', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const trashLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-trash-label-id',
+                specialUse: 'TRASH',
+            };
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runTrash = mock(async () => trashLabel);
+            const oneLabel = mock(() => ({ run: runTrash }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runExisting = mock(async () => null);
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabel = mock(() => ({ one: oneExisting }));
+            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const threadLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    threadLabel: {
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setTrash(transaction, {
+                threadIds: ['test-thread-id-1'],
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith({
+                labelId: 'test-trash-label-id',
+                threadId: 'test-thread-id-1',
+            });
+        });
+    });
+});

package/dist/zero/mutators/userMutators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './userMutators';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}

package/dist/zero/mutators/userMutators/index.js

@@ -0,0 +1 @@
+export * from './userMutators';

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

@@ -0,0 +1,8 @@
+import type * as v from 'valibot';
+import type { AuthData, HandlerMap } from '../../../types';
+import type { userMutatorSchemas } from '../../../zero/mutatorSchemas';
+export type UserMutatorCallbacks = {
+    [K in keyof typeof userMutatorSchemas]?: (args: v.InferOutput<(typeof userMutatorSchemas)[K]['delta']>) => Promise<void>;
+};
+export declare const createUserMutators: (_authData: AuthData | undefined, callbacks?: UserMutatorCallbacks) => HandlerMap<typeof userMutatorSchemas>;
+//# sourceMappingURL=userMutators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,oBAAoB,GAAG;KAChC,CAAC,IAAI,MAAM,OAAO,kBAAkB,CAAC,CAAC,EAAE,CACvC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KACzD,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,kBAAkB,cAClB,QAAQ,GAAG,SAAS,cACnB,oBAAoB,KAC/B,UAAU,CAAC,OAAO,kBAAkB,CAuCrC,CAAA"}

package/dist/zero/mutators/userMutators/userMutators.js

@@ -0,0 +1,37 @@
+export const createUserMutators = (_authData, callbacks) => ({
+    deleteSettingsPushNotificationToken: async (tx, args) => {
+        await tx.mutate.userPushNotificationToken.delete({
+            id: args.id,
+        });
+        await callbacks?.deleteSettingsPushNotificationToken?.(args);
+    },
+    setSettingsName: async (tx, args) => {
+        await tx.mutate.user.update({
+            id: args.id,
+            name: args.name,
+        });
+        await callbacks?.setSettingsName?.(args);
+    },
+    setSettingsPushNotificationToken: async (tx, args) => {
+        const existing = await tx.query.userPushNotificationToken
+            .where('userId', args.id)
+            .where('token', args.pushNotificationToken.token)
+            .one()
+            .run();
+        if (existing) {
+            await tx.mutate.userPushNotificationToken.update({
+                createdAt: args.pushNotificationToken.createdAt,
+                id: existing.id,
+            });
+        }
+        else {
+            await tx.mutate.userPushNotificationToken.insert({
+                createdAt: args.pushNotificationToken.createdAt,
+                id: `${args.id}-${args.pushNotificationToken.deviceId}`,
+                token: args.pushNotificationToken.token,
+                userId: args.id,
+            });
+        }
+        await callbacks?.setSettingsPushNotificationToken?.(args);
+    },
+});

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

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

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

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

package/dist/zero/mutators/userMutators/userMutators.test.js

@@ -0,0 +1,123 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createMutators } from '../mutators';
+describe('userMutators', () => {
+    describe('deleteSettingsPushNotificationToken', () => {
+        it('deletes push notification token', async () => {
+            const tokenDelete = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    userPushNotificationToken: {
+                        delete: tokenDelete,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.user.deleteSettingsPushNotificationToken(transaction, {
+                id: 'test-user-id',
+                token: 'test-token',
+            });
+            expect(tokenDelete).toHaveBeenCalledWith({
+                id: 'test-user-id',
+            });
+        });
+    });
+    describe('setSettingsName', () => {
+        it('sets user name', async () => {
+            const userUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    user: {
+                        update: userUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.user.setSettingsName(transaction, {
+                id: 'test-user-id',
+                name: 'John Doe',
+            });
+            expect(userUpdate).toHaveBeenCalledWith({
+                id: 'test-user-id',
+                name: 'John Doe',
+            });
+        });
+    });
+    describe('setSettingsPushNotificationToken', () => {
+        it('sets push notification token when token does not exist', async () => {
+            const run = mock(async () => null);
+            const one = mock(() => ({ run }));
+            const whereToken = mock(() => ({ one }));
+            const whereUserId = mock(() => ({ where: whereToken }));
+            const tokenInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    userPushNotificationToken: {
+                        insert: tokenInsert,
+                        update: mock(async () => { }),
+                    },
+                },
+                query: {
+                    userPushNotificationToken: {
+                        where: whereUserId,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.user.setSettingsPushNotificationToken(transaction, {
+                id: 'test-user-id',
+                pushNotificationToken: {
+                    createdAt: 1_000,
+                    deviceId: 'test-device-id',
+                    token: 'test-token',
+                },
+            });
+            expect(tokenInsert).toHaveBeenCalledWith({
+                createdAt: 1_000,
+                id: 'test-user-id-test-device-id',
+                token: 'test-token',
+                userId: 'test-user-id',
+            });
+        });
+        it('updates push notification token when token exists', async () => {
+            const existingToken = {
+                createdAt: 500,
+                id: 'test-user-id-test-device-id',
+                token: 'test-token',
+                userId: 'test-user-id',
+            };
+            const run = mock(async () => existingToken);
+            const one = mock(() => ({ run }));
+            const whereToken = mock(() => ({ one }));
+            const whereUserId = mock(() => ({ where: whereToken }));
+            const tokenUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    userPushNotificationToken: {
+                        insert: mock(async () => { }),
+                        update: tokenUpdate,
+                    },
+                },
+                query: {
+                    userPushNotificationToken: {
+                        where: whereUserId,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.user.setSettingsPushNotificationToken(transaction, {
+                id: 'test-user-id',
+                pushNotificationToken: {
+                    createdAt: 2_000,
+                    deviceId: 'test-device-id',
+                    token: 'test-token',
+                },
+            });
+            expect(tokenUpdate).toHaveBeenCalledWith({
+                createdAt: 2_000,
+                id: 'test-user-id-test-device-id',
+            });
+        });
+    });
+});