@marcoappio/marco-config 2.0.491 → 2.0.493

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

@@ -1,390 +0,0 @@
-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(() => { });
-            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(() => { });
-            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(() => { });
-            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/draftMutators/draftMutators.test.d.ts

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

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

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