@marcoappio/marco-config 2.0.503 → 2.0.505

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

@@ -0,0 +1,416 @@
+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/draftMutators/index.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

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

@@ -1 +1 @@
-export { draftMutatorSchemas, draftMutators } from './draftMutators';
+export * from './draftMutators';