@marcoappio/marco-config 2.0.491 → 2.0.493

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

@@ -1,416 +0,0 @@
-import { describe, expect, it, mock } from 'bun:test';
-import { createMutators } from '../mutators';
-describe('draftMutators', () => {
-    describe('scheduleSend', () => {
-        it('marks immediate schedule send drafts as send requested', async () => {
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators();
-            await mutators.draft.scheduleSend(transaction, {
-                id: 'test-draft-id-1',
-                kind: 'IMMEDIATE',
-                undoMs: 15_000,
-                updatedAt: 1_000,
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                id: 'test-draft-id-1',
-                scheduledFor: 16_000,
-                status: 'SEND_REQUESTED',
-                updatedAt: 1_000,
-            });
-        });
-    });
-    describe('setContent', () => {
-        it('applies string patches when updating draft content', async () => {
-            const draftRecord = {
-                body: { content: 'hello' },
-                id: 'test-draft-id-1',
-            };
-            const run = mock(async () => draftRecord);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {
-                    draft: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await mutators.draft.setContent(transaction, {
-                id: 'test-draft-id-1',
-                patch: [
-                    {
-                        index: 5,
-                        type: 'INSERTION',
-                        value: '!',
-                    },
-                ],
-                updatedAt: 2_000,
-            });
-            expect(where).toHaveBeenCalledWith('id', 'test-draft-id-1');
-            expect(draftUpdate).toHaveBeenCalledWith({
-                body: {
-                    content: 'hello!',
-                },
-                id: 'test-draft-id-1',
-                updatedAt: 2_000,
-            });
-        });
-    });
-    describe('cancelSend', () => {
-        it('cancels draft send', async () => {
-            const draftRecord = {
-                id: 'test-draft-id-1',
-                status: 'SEND_REQUESTED',
-            };
-            const run = mock(async () => draftRecord);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {
-                    draft: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await mutators.draft.cancelSend(transaction, {
-                id: 'test-draft-id-1',
-                updatedAt: 5_000,
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                id: 'test-draft-id-1',
-                scheduledFor: null,
-                status: 'DRAFT',
-                updatedAt: 5_000,
-            });
-        });
-        it('throws error when draft is already sent', async () => {
-            const draftRecord = {
-                id: 'test-draft-id-1',
-                status: 'SEND_CONFIRMED',
-            };
-            const run = mock(async () => draftRecord);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {
-                    draft: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await expect(mutators.draft.cancelSend(transaction, {
-                id: 'test-draft-id-1',
-                updatedAt: 5_000,
-            })).rejects.toThrow('MutationError/ALREADY_APPLIED');
-            expect(draftUpdate).not.toHaveBeenCalled();
-        });
-        it('throws error when draft not found', async () => {
-            const run = mock(async () => null);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {
-                    draft: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await expect(mutators.draft.cancelSend(transaction, {
-                id: 'test-draft-id-1',
-                updatedAt: 5_000,
-            })).rejects.toThrow('MutationError/ENTITY_NOT_FOUND');
-            expect(draftUpdate).not.toHaveBeenCalled();
-        });
-    });
-    describe('createAttachment', () => {
-        it('creates draft attachment', async () => {
-            const draftAttachmentInsert = mock(async () => { });
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                    draftAttachment: {
-                        delete: mock(async () => { }),
-                        insert: draftAttachmentInsert,
-                        update: mock(async () => { }),
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators();
-            await mutators.draft.createAttachment(transaction, {
-                attachment: {
-                    fileName: 'test-document.pdf',
-                    id: 'test-attachment-id-1',
-                    mimeType: 'application/pdf',
-                    status: 'PENDING',
-                    totalSize: 1024000,
-                },
-                id: 'test-draft-id-1',
-                updatedAt: 3_000,
-            });
-            expect(draftAttachmentInsert).toHaveBeenCalledWith({
-                draftId: 'test-draft-id-1',
-                fileName: 'test-document.pdf',
-                id: 'test-attachment-id-1',
-                mimeType: 'application/pdf',
-                status: 'PENDING',
-                totalSize: 1024000,
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                id: 'test-draft-id-1',
-                updatedAt: 3_000,
-            });
-        });
-    });
-    describe('createDraft', () => {
-        it('creates a draft', async () => {
-            const draftInsert = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: draftInsert,
-                        update: mock(async () => { }),
-                    },
-                    draftAttachment: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: mock(async () => { }),
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators({ sub: 'test-user-id' });
-            await mutators.draft.createDraft(transaction, {
-                accountId: 'test-account-id-1',
-                attachments: [],
-                body: {
-                    bcc: [],
-                    cc: [],
-                    content: 'Draft content',
-                    subject: 'Test Subject',
-                    to: ['recipient@example.com'],
-                },
-                error: null,
-                from: 'sender@example.com',
-                fromName: 'Test Sender',
-                id: 'test-draft-id-2',
-                referencedMessageId: null,
-                scheduledFor: null,
-                status: 'DRAFT',
-                type: 'NEW',
-                updatedAt: 1_000,
-            });
-            expect(draftInsert).toHaveBeenCalledWith({
-                accountId: 'test-account-id-1',
-                body: {
-                    bcc: [],
-                    cc: [],
-                    content: 'Draft content',
-                    to: ['recipient@example.com'],
-                },
-                error: null,
-                fromAliasId: null,
-                fromEmail: 'sender@example.com',
-                fromName: 'Test Sender',
-                id: 'test-draft-id-2',
-                referencedMessageId: null,
-                scheduledFor: null,
-                status: 'DRAFT',
-                subject: 'Test Subject',
-                type: 'NEW',
-                updatedAt: 1_000,
-                userId: 'test-user-id',
-            });
-        });
-    });
-    describe('deleteAttachment', () => {
-        it('deletes draft attachment', async () => {
-            const draftAttachmentDelete = mock(async () => { });
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                    draftAttachment: {
-                        delete: draftAttachmentDelete,
-                        insert: mock(async () => { }),
-                        update: mock(async () => { }),
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators();
-            await mutators.draft.deleteAttachment(transaction, {
-                attachmentId: 'test-attachment-id-1',
-                id: 'test-draft-id-1',
-                updatedAt: 4_000,
-            });
-            expect(draftAttachmentDelete).toHaveBeenCalledWith({
-                id: 'test-attachment-id-1',
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                id: 'test-draft-id-1',
-                updatedAt: 4_000,
-            });
-        });
-    });
-    describe('deleteDraft', () => {
-        it('deletes a draft', async () => {
-            const draftDelete = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: draftDelete,
-                        insert: mock(async () => { }),
-                        update: mock(async () => { }),
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators();
-            await mutators.draft.deleteDraft(transaction, {
-                id: 'test-draft-id-1',
-            });
-            expect(draftDelete).toHaveBeenCalledWith({
-                id: 'test-draft-id-1',
-            });
-        });
-    });
-    describe('setEnvelope', () => {
-        it('sets draft envelope', async () => {
-            const draftRecord = {
-                body: {
-                    content: 'Existing content',
-                },
-                id: 'test-draft-id-1',
-            };
-            const run = mock(async () => draftRecord);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {
-                    draft: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await mutators.draft.setEnvelope(transaction, {
-                envelope: {
-                    bcc: ['bcc@example.com'],
-                    cc: ['cc@example.com'],
-                    subject: 'Updated Subject',
-                    to: ['to@example.com'],
-                },
-                id: 'test-draft-id-1',
-                updatedAt: 6_000,
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                body: {
-                    bcc: ['bcc@example.com'],
-                    cc: ['cc@example.com'],
-                    content: 'Existing content',
-                    to: ['to@example.com'],
-                },
-                id: 'test-draft-id-1',
-                subject: 'Updated Subject',
-                updatedAt: 6_000,
-            });
-        });
-    });
-    describe('setFrom', () => {
-        it('sets draft from address', async () => {
-            const draftUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draft: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftUpdate,
-                    },
-                },
-                query: {},
-            };
-            const mutators = createMutators();
-            await mutators.draft.setFrom(transaction, {
-                accountId: 'test-account-id-1',
-                aliasId: 'test-alias-id-1',
-                from: 'sender@example.com',
-                fromName: 'Updated Sender',
-                id: 'test-draft-id-1',
-                updatedAt: 7_000,
-            });
-            expect(draftUpdate).toHaveBeenCalledWith({
-                accountId: 'test-account-id-1',
-                fromAliasId: 'test-alias-id-1',
-                fromEmail: 'sender@example.com',
-                fromName: 'Updated Sender',
-                id: 'test-draft-id-1',
-                updatedAt: 7_000,
-            });
-        });
-    });
-});

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

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

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

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