@marcoappio/marco-config 2.0.504 → 2.0.505

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

@@ -0,0 +1,372 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createMutators, ZeroMutatorValidationError } from '../mutators';
+describe('accountMutators', () => {
+    describe('createAccount', () => {
+        it('creates an account', async () => {
+            const accountInsert = mock(async () => { });
+            const accountAliasInsert = mock(async () => { });
+            const mutators = createMutators({ sub: 'test-user-id' });
+            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(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 mutators = createMutators({ sub: 'test-user-id' });
+            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',
+            });
+        });
+    });
+    describe('deleteAccount', () => {
+        it('deletes an account', async () => {
+            const accountDelete = mock(async () => { });
+            const mutators = createMutators({ sub: 'test-user-id' });
+            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',
+            });
+        });
+    });
+    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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/accountMutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}
+{"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

@@ -1 +1 @@
-export { accountMutatorSchemas, accountMutators } from './accountMutators';
+export * from './accountMutators';