@marcoappio/marco-config 2.0.426 → 2.0.428

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

@@ -0,0 +1,390 @@
+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 draftUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    draft: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: draftUpdate,
+                    },
+                },
+                query: {},
+            };
+            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,
+            });
+        });
+    });
+    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: {
+                    failed: false,
+                    fileName: 'test-document.pdf',
+                    id: 'test-attachment-id-1',
+                    mimeType: 'application/pdf',
+                    totalChunks: 5,
+                    totalSize: 1024000,
+                    uploadedChunks: 0,
+                },
+                id: 'test-draft-id-1',
+                updatedAt: 3_000,
+            });
+            expect(draftAttachmentInsert).toHaveBeenCalledWith({
+                draftId: 'test-draft-id-1',
+                failed: false,
+                fileName: 'test-document.pdf',
+                id: 'test-attachment-id-1',
+                mimeType: 'application/pdf',
+                totalChunks: 5,
+                totalSize: 1024000,
+                uploadedChunks: 0,
+            });
+            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, {
+                attachments: [],
+                body: {
+                    bcc: [],
+                    cc: [],
+                    content: 'Draft content',
+                    subject: 'Test Subject',
+                    to: ['recipient@example.com'],
+                },
+                emailAccountId: 'test-account-id-1',
+                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, {
+                aliasId: 'test-alias-id-1',
+                emailAccountId: 'test-account-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,
+            });
+        });
+    });
+    describe('uploadAttachmentChunk', () => {
+        it('uploads attachment chunk', async () => {
+            const attachmentRecord = {
+                id: 'test-attachment-id-1',
+                uploadedChunks: 2,
+            };
+            const run = mock(async () => attachmentRecord);
+            const one = mock(() => ({ run }));
+            const where = mock(() => ({ one }));
+            const draftAttachmentUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    draftAttachment: {
+                        delete: mock(async () => { }),
+                        insert: mock(async () => { }),
+                        update: draftAttachmentUpdate,
+                    },
+                },
+                query: {
+                    draftAttachment: {
+                        where,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.draft.uploadAttachmentChunk(transaction, {
+                attachmentId: 'test-attachment-id-1',
+                chunk: 'dGVzdC1jaHVuaw==',
+                chunkIndex: 3,
+                id: 'test-draft-id-1',
+            });
+            expect(draftAttachmentUpdate).toHaveBeenCalledWith({
+                id: 'test-attachment-id-1',
+                uploadedChunks: 4,
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1 @@
+export * from './draftMutators';