@marcoappio/marco-config 2.0.508 → 2.0.509

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

@@ -1,103 +0,0 @@
-import { MutationError } from '../../../types';
-export const createAccountMutators = (authData) => ({
-    createAccount: async (tx, args) => {
-        if (!authData) {
-            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
-        }
-        await tx.mutate.account.insert({
-            color: args.color,
-            displayName: null,
-            id: args.id,
-            imapConnectionStatus: 'AWAITING_CONNECTION',
-            mailProcessedCount: 0,
-            mailTotalCount: 0,
-            primaryAliasId: args.aliasId,
-            userId: authData.sub,
-        });
-        await tx.mutate.accountAlias.insert({
-            accountId: args.id,
-            emailAddress: args.emailAddress,
-            id: args.aliasId,
-            isPrimary: true,
-            name: null,
-        });
-    },
-    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: async (tx, args) => {
-        await tx.mutate.account.delete({
-            id: args.id,
-        });
-    },
-    deleteAlias: async (tx, args) => {
-        const alias = await tx.query.accountAlias.where('id', args.aliasId).one().run();
-        await tx.mutate.accountAlias.delete({
-            id: args.aliasId,
-        });
-        if (alias?.isPrimary) {
-            const remainingAliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
-            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: async (tx, args) => {
-        await tx.mutate.accountAlias.update({
-            id: args.aliasId,
-            name: args.displayName,
-        });
-    },
-    setAliasPrimary: async (tx, args) => {
-        const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
-        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: async (tx, args) => {
-        await tx.mutate.account.update({
-            id: args.id,
-            imapConnectionStatus: 'AWAITING_CONNECTION',
-        });
-    },
-    setConnectionConfigOauth: async (tx, args) => {
-        await tx.mutate.account.update({
-            id: args.id,
-            imapConnectionStatus: 'AWAITING_CONNECTION',
-        });
-    },
-    setSettings: async (tx, args) => {
-        await tx.mutate.account.update({
-            color: args.color ? args.color : undefined,
-            displayName: args.displayName ? args.displayName : undefined,
-            id: args.id,
-        });
-    },
-});

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

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

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

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

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

@@ -1,372 +0,0 @@
-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 +0,0 @@
-export * from './accountMutators';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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 +0,0 @@
-export * from './accountMutators';

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

@@ -1,4 +0,0 @@
-import { type AuthData, type HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-export declare const createDraftMutators: (authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["draft"]>;
-//# sourceMappingURL=draftMutators.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,mBAAmB,aAAc,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAwJzG,CAAA"}

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

@@ -1,142 +0,0 @@
-import { MutationError } from '../../../types';
-import { stringPatch } from '../../../utils';
-export const createDraftMutators = (authData) => ({
-    cancelSend: async (tx, args) => {
-        const draft = await tx.query.draft.where('id', args.id).one().run();
-        if (!draft) {
-            throw new Error(MutationError.ENTITY_NOT_FOUND);
-        }
-        if (draft.status === 'SEND_CONFIRMED') {
-            throw new Error(MutationError.ALREADY_APPLIED);
-        }
-        await tx.mutate.draft.update({
-            id: args.id,
-            scheduledFor: null,
-            status: 'DRAFT',
-            updatedAt: args.updatedAt,
-        });
-    },
-    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: async (tx, args) => {
-        if (!authData) {
-            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
-        }
-        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: authData.sub,
-        });
-        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: async (tx, args) => {
-        await tx.mutate.draftAttachment.delete({
-            id: args.attachmentId,
-        });
-        await tx.mutate.draft.update({
-            id: args.id,
-            updatedAt: args.updatedAt,
-        });
-    },
-    deleteDraft: async (tx, args) => {
-        await tx.mutate.draft.delete({
-            id: args.id,
-        });
-    },
-    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: 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: {
-                ...draft.body,
-                content: stringPatch.apply(typeof draft.body?.content === 'string' ? draft.body.content : '', args.patch),
-            },
-            id: args.id,
-            updatedAt: args.updatedAt,
-        });
-    },
-    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,
-        });
-    },
-    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,
-        });
-    },
-});

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":""}