@marcoappio/marco-config 2.0.426 → 2.0.428

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

@@ -0,0 +1,390 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createMutators, ZeroMutatorValidationError } from '../mutators';
+describe('accountMutators', () => {
+    describe('createAccount', () => {
+        it('creates an account and invokes the callback', async () => {
+            const accountInsert = mock(async () => { });
+            const accountAliasInsert = mock(async () => { });
+            const createAccountCallback = mock(async () => { });
+            const mutators = createMutators({ sub: 'test-user-id' }, {
+                account: {
+                    createAccount: createAccountCallback,
+                },
+            });
+            const payload = {
+                aliasId: 'test-alias-id-1',
+                color: '#ff0000',
+                emailAddress: 'user@example.com',
+                id: 'test-account-id-1',
+            };
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: accountInsert,
+                        update: mock(async () => { }),
+                    },
+                    accountAlias: {
+                        delete: mock(async () => { }),
+                        insert: accountAliasInsert,
+                        update: mock(async () => { }),
+                    },
+                },
+                query: {},
+            };
+            await mutators.account.createAccount(transaction, payload);
+            expect(accountInsert).toHaveBeenCalledWith({
+                color: payload.color,
+                displayName: null,
+                id: payload.id,
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+                mailProcessedCount: 0,
+                mailTotalCount: 0,
+                primaryAliasId: payload.aliasId,
+                userId: 'test-user-id',
+            });
+            expect(accountAliasInsert).toHaveBeenCalledWith({
+                accountId: payload.id,
+                emailAddress: payload.emailAddress,
+                id: payload.aliasId,
+                isPrimary: true,
+                name: null,
+            });
+            expect(createAccountCallback).toHaveBeenCalledWith(payload);
+            expect(accountInsert.mock.invocationCallOrder[0]).toBeLessThan(accountAliasInsert.mock.invocationCallOrder[0]);
+        });
+        it('throws ZeroMutatorValidationError on invalid payloads', async () => {
+            const mutators = createMutators({ sub: 'test-user-id' });
+            await expect(mutators.account.createAccount({
+                mutate: {},
+                query: {},
+            }, {
+                aliasId: 'test-alias-id-1',
+                color: 'blue',
+                emailAddress: 'invalid-email',
+                id: 'test-account-id-1',
+            })).rejects.toBeInstanceOf(ZeroMutatorValidationError);
+        });
+    });
+    describe('createAlias', () => {
+        it('creates an alias', async () => {
+            const accountAliasInsert = mock(async () => { });
+            const createAliasCallback = mock(async () => { });
+            const mutators = createMutators({ sub: 'test-user-id' }, {
+                account: {
+                    createAlias: createAliasCallback,
+                },
+            });
+            const transaction = {
+                mutate: {
+                    accountAlias: {
+                        delete: mock(async () => { }),
+                        insert: accountAliasInsert,
+                        update: mock(async () => { }),
+                    },
+                },
+                query: {},
+            };
+            await mutators.account.createAlias(transaction, {
+                accountId: 'test-account-id-1',
+                alias: {
+                    emailAddress: 'alias@example.com',
+                    id: 'test-alias-id-2',
+                    name: 'Work Email',
+                },
+            });
+            expect(accountAliasInsert).toHaveBeenCalledWith({
+                accountId: 'test-account-id-1',
+                emailAddress: 'alias@example.com',
+                id: 'test-alias-id-2',
+                isPrimary: false,
+                name: 'Work Email',
+            });
+            expect(createAliasCallback).toHaveBeenCalled();
+        });
+    });
+    describe('deleteAccount', () => {
+        it('deletes an account', async () => {
+            const accountDelete = mock(async () => { });
+            const deleteAccountCallback = mock(async () => { });
+            const mutators = createMutators({ sub: 'test-user-id' }, {
+                account: {
+                    deleteAccount: deleteAccountCallback,
+                },
+            });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: accountDelete,
+                        insert: mock(async () => { }),
+                        update: mock(async () => { }),
+                    },
+                },
+                query: {},
+            };
+            await mutators.account.deleteAccount(transaction, {
+                id: 'test-account-id-1',
+            });
+            expect(accountDelete).toHaveBeenCalledWith({
+                id: 'test-account-id-1',
+            });
+            expect(deleteAccountCallback).toHaveBeenCalled();
+        });
+    });
+    describe('deleteAlias', () => {
+        it('deletes a non-primary alias', async () => {
+            const aliasRecord = {
+                id: 'test-alias-id-2',
+                isPrimary: false,
+            };
+            const run = mock(async () => aliasRecord);
+            const one = mock(() => ({ run }));
+            const where = mock(() => ({ one }));
+            const accountAliasDelete = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountAlias: {
+                        delete: accountAliasDelete,
+                        insert: mock(async () => { }),
+                        update: mock(async () => { }),
+                    },
+                },
+                query: {
+                    accountAlias: {
+                        where,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.account.deleteAlias(transaction, {
+                accountId: 'test-account-id-1',
+                aliasId: 'test-alias-id-2',
+            });
+            expect(accountAliasDelete).toHaveBeenCalledWith({
+                id: 'test-alias-id-2',
+            });
+        });
+        it('deletes a primary alias and assigns new primary', async () => {
+            const aliasRecord = {
+                id: 'test-alias-id-1',
+                isPrimary: true,
+            };
+            const remainingAliases = [
+                {
+                    id: 'test-alias-id-2',
+                    isPrimary: false,
+                },
+            ];
+            const runOne = mock(async () => aliasRecord);
+            const one = mock(() => ({ run: runOne }));
+            const runList = mock(async () => remainingAliases);
+            const where = mock((field) => {
+                if (field === 'accountId') {
+                    return { run: runList };
+                }
+                return { one };
+            });
+            const accountAliasDelete = mock(async () => { });
+            const accountAliasUpdate = mock(async () => { });
+            const accountUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountUpdate,
+                    },
+                    accountAlias: {
+                        delete: accountAliasDelete,
+                        insert: mock(async () => { }),
+                        update: accountAliasUpdate,
+                    },
+                },
+                query: {
+                    accountAlias: {
+                        where,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.account.deleteAlias(transaction, {
+                accountId: 'test-account-id-1',
+                aliasId: 'test-alias-id-1',
+            });
+            expect(accountAliasDelete).toHaveBeenCalledWith({
+                id: 'test-alias-id-1',
+            });
+            expect(accountAliasUpdate).toHaveBeenCalledWith({
+                id: 'test-alias-id-2',
+                isPrimary: true,
+            });
+            expect(accountUpdate).toHaveBeenCalledWith({
+                id: 'test-account-id-1',
+                primaryAliasId: 'test-alias-id-2',
+            });
+        });
+    });
+    describe('setAliasName', () => {
+        it('sets alias name', async () => {
+            const accountAliasUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountAlias: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountAliasUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.account.setAliasName(transaction, {
+                accountId: 'test-account-id-1',
+                aliasId: 'test-alias-id-1',
+                displayName: 'New Name',
+            });
+            expect(accountAliasUpdate).toHaveBeenCalledWith({
+                id: 'test-alias-id-1',
+                name: 'New Name',
+            });
+        });
+    });
+    describe('setAliasPrimary', () => {
+        it('sets alias as primary', async () => {
+            const aliases = [
+                { id: 'test-alias-id-1', isPrimary: true },
+                { id: 'test-alias-id-2', isPrimary: false },
+            ];
+            const run = mock(async () => aliases);
+            const where = mock(() => ({ run }));
+            const accountAliasUpdate = mock(async () => { });
+            const accountUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountUpdate,
+                    },
+                    accountAlias: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountAliasUpdate,
+                    },
+                },
+                query: {
+                    accountAlias: {
+                        where,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.account.setAliasPrimary(transaction, {
+                accountId: 'test-account-id-1',
+                aliasId: 'test-alias-id-2',
+            });
+            expect(accountAliasUpdate).toHaveBeenCalledTimes(2);
+            expect(accountAliasUpdate).toHaveBeenCalledWith({
+                id: 'test-alias-id-1',
+                isPrimary: false,
+            });
+            expect(accountAliasUpdate).toHaveBeenCalledWith({
+                id: 'test-alias-id-2',
+                isPrimary: true,
+            });
+            expect(accountUpdate).toHaveBeenCalledWith({
+                id: 'test-account-id-1',
+                primaryAliasId: 'test-alias-id-2',
+            });
+        });
+    });
+    describe('setConnectionConfigImapRaw', () => {
+        it('sets connection config for IMAP raw', async () => {
+            const accountUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.account.setConnectionConfigImapRaw(transaction, {
+                connectionConfig: {
+                    imapHost: 'imap.example.com',
+                    imapPassword: 'test-password',
+                    imapPort: 993,
+                    imapSocketType: 'SSL',
+                    imapUser: 'user@example.com',
+                    smtpHost: 'smtp.example.com',
+                    smtpPassword: 'test-password',
+                    smtpPort: 465,
+                    smtpSocketType: 'SSL',
+                    smtpUser: 'user@example.com',
+                },
+                id: 'test-account-id-1',
+            });
+            expect(accountUpdate).toHaveBeenCalledWith({
+                id: 'test-account-id-1',
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+            });
+        });
+    });
+    describe('setConnectionConfigOauth', () => {
+        it('sets connection config for OAuth', async () => {
+            const accountUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.account.setConnectionConfigOauth(transaction, {
+                connectionConfig: {
+                    code: 'test-auth-code',
+                    provider: 'GOOGLE',
+                    user: 'user@example.com',
+                },
+                id: 'test-account-id-1',
+            });
+            expect(accountUpdate).toHaveBeenCalledWith({
+                id: 'test-account-id-1',
+                imapConnectionStatus: 'AWAITING_CONNECTION',
+            });
+        });
+    });
+    describe('setSettings', () => {
+        it('sets account settings', async () => {
+            const accountUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    account: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: accountUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.account.setSettings(transaction, {
+                color: '#00ff00',
+                displayName: 'Work Account',
+                id: 'test-account-id-1',
+            });
+            expect(accountUpdate).toHaveBeenCalledWith({
+                color: '#00ff00',
+                displayName: 'Work Account',
+                id: 'test-account-id-1',
+            });
+        });
+    });
+});

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAE5E,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,OAAO,mBAAmB,CAAC,CAAC,EAAE,CACxC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAC1D,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,GAAG,SAAS,cAClB,qBAAqB,KAChC,UAAU,CAAC,OAAO,mBAAmB,CAwLtC,CAAA"}

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

@@ -0,0 +1,162 @@
+import { MutationError } from '../../../types';
+import { stringPatch } from '../../../utils';
+export const createDraftMutators = (authData, callbacks) => ({
+    cancelSend: async (tx, args) => {
+        await tx.mutate.draft.update({
+            id: args.id,
+            scheduledFor: null,
+            status: 'DRAFT',
+            updatedAt: args.updatedAt,
+        });
+        await callbacks?.cancelSend?.(args);
+    },
+    createAttachment: async (tx, args) => {
+        await tx.mutate.draftAttachment.insert({
+            draftId: args.id,
+            failed: args.attachment.failed,
+            fileName: args.attachment.fileName,
+            id: args.attachment.id,
+            mimeType: args.attachment.mimeType,
+            totalChunks: args.attachment.totalChunks,
+            totalSize: args.attachment.totalSize,
+            uploadedChunks: args.attachment.uploadedChunks,
+        });
+        await tx.mutate.draft.update({
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+        await callbacks?.createAttachment?.(args);
+    },
+    createDraft: async (tx, args) => {
+        if (!authData) {
+            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
+        }
+        await tx.mutate.draft.insert({
+            accountId: args.emailAccountId,
+            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: authData.sub,
+        });
+        for (const attachment of args.attachments) {
+            await tx.mutate.draftAttachment.insert({
+                draftId: args.id,
+                failed: attachment.failed,
+                fileName: attachment.fileName,
+                id: attachment.id,
+                mimeType: attachment.mimeType,
+                totalChunks: attachment.totalChunks,
+                totalSize: attachment.totalSize,
+                uploadedChunks: attachment.uploadedChunks,
+            });
+        }
+        await callbacks?.createDraft?.(args);
+    },
+    deleteAttachment: async (tx, args) => {
+        await tx.mutate.draftAttachment.delete({
+            id: args.attachmentId,
+        });
+        await tx.mutate.draft.update({
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+        await callbacks?.deleteAttachment?.(args);
+    },
+    deleteDraft: async (tx, args) => {
+        await tx.mutate.draft.delete({
+            id: args.id,
+        });
+        await callbacks?.deleteDraft?.(args);
+    },
+    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,
+            });
+        }
+        await callbacks?.scheduleSend?.(args);
+    },
+    setContent: async (tx, args) => {
+        const draft = await tx.query.draft.where('id', args.id).one().run();
+        if (!draft) {
+            throw new Error(MutationError.ENTITY_NOT_FOUND);
+        }
+        const currentContent = typeof draft.body?.content === 'string' ? draft.body.content : '';
+        const updatedBody = {
+            ...draft.body,
+            content: stringPatch.apply(currentContent, args.patch),
+        };
+        await tx.mutate.draft.update({
+            body: updatedBody,
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+        await callbacks?.setContent?.(args);
+    },
+    setEnvelope: async (tx, args) => {
+        const draft = await tx.query.draft.where('id', args.id).one().run();
+        if (!draft) {
+            throw new Error(MutationError.ENTITY_NOT_FOUND);
+        }
+        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,
+        });
+        await callbacks?.setEnvelope?.(args);
+    },
+    setFrom: async (tx, args) => {
+        await tx.mutate.draft.update({
+            accountId: args.emailAccountId,
+            fromAliasId: args.aliasId,
+            fromEmail: args.from,
+            fromName: args.fromName,
+            id: args.id,
+            updatedAt: args.updatedAt,
+        });
+        await callbacks?.setFrom?.(args);
+    },
+    uploadAttachmentChunk: async (tx, args) => {
+        const attachment = await tx.query.draftAttachment.where('id', args.attachmentId).one().run();
+        if (!attachment) {
+            throw new Error(MutationError.ENTITY_NOT_FOUND);
+        }
+        const uploadedChunks = Math.max(typeof attachment.uploadedChunks === 'number' ? attachment.uploadedChunks : 0, args.chunkIndex + 1);
+        await tx.mutate.draftAttachment.update({
+            id: args.attachmentId,
+            uploadedChunks,
+        });
+        await callbacks?.uploadAttachmentChunk?.(args);
+    },
+});

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

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

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

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