@marcoappio/marco-config 2.0.508 → 2.0.510

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/draftMutators/index.d.ts

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

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

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

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

@@ -1,3 +0,0 @@
-export type { MarcoZeroMutators } from './mutators';
-export { createMutators, ZeroMutatorValidationError } from './mutators';
-//# sourceMappingURL=index.d.ts.map

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

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

package/dist/zero/mutators/index.js

@@ -1 +0,0 @@
-export { createMutators, ZeroMutatorValidationError } from './mutators';

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

@@ -1,18 +0,0 @@
-import * as v from 'valibot';
-import type { MutatorMap } from '../../types';
-import { type ZeroMutatorSchemas } from '../../zero/mutatorSchemas';
-export type AuthData = {
-    sub: string;
-};
-export declare class ZeroMutatorValidationError extends Error {
-    readonly issues: ReturnType<typeof v.flatten>;
-    constructor(issues: ReturnType<typeof v.flatten>);
-}
-export type MarcoZeroMutators = {
-    account: MutatorMap<ZeroMutatorSchemas['account']>;
-    draft: MutatorMap<ZeroMutatorSchemas['draft']>;
-    thread: MutatorMap<ZeroMutatorSchemas['thread']>;
-    user: MutatorMap<ZeroMutatorSchemas['user']>;
-};
-export declare const createMutators: (authData?: AuthData) => MarcoZeroMutators;
-//# sourceMappingURL=mutators.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAkD,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrG,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,mCAAmC,CAAA;AAQ/F,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AA8BD,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;gBAApC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;CAG1D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAA;IAClD,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,cAAc,cAAe,QAAQ,KAAG,iBAKnD,CAAA"}

package/dist/zero/mutators/mutators.js

@@ -1,39 +0,0 @@
-import * as v from 'valibot';
-import { zeroMutatorSchemas } from '../../zero/mutatorSchemas';
-import { createAccountMutators } from './accountMutators';
-import { createDraftMutators } from './draftMutators';
-import { createThreadMutators } from './threadMutators';
-import { createUserMutators } from './userMutators';
-const validateArgs = (schema, input) => {
-    const parsed = v.safeParse(schema, input);
-    if (!parsed.success) {
-        throw new ZeroMutatorValidationError(v.flatten(parsed.issues));
-    }
-    return parsed.output;
-};
-const createValidatingMutator = (schema, handler) => {
-    return async (tx, input) => {
-        const args = validateArgs(schema, input);
-        await handler(tx, args);
-    };
-};
-const buildMutatorMap = (defs, handlers) => {
-    const entries = Object.entries(defs).map(([name, definition]) => [
-        name,
-        createValidatingMutator(definition.delta, handlers[name]),
-    ]);
-    return Object.fromEntries(entries);
-};
-export class ZeroMutatorValidationError extends Error {
-    issues;
-    constructor(issues) {
-        super('Zero mutator payload failed validation');
-        this.issues = issues;
-    }
-}
-export const createMutators = (authData) => ({
-    account: buildMutatorMap(zeroMutatorSchemas.account, createAccountMutators(authData)),
-    draft: buildMutatorMap(zeroMutatorSchemas.draft, createDraftMutators(authData)),
-    thread: buildMutatorMap(zeroMutatorSchemas.thread, createThreadMutators(authData)),
-    user: buildMutatorMap(zeroMutatorSchemas.user, createUserMutators(authData)),
-});

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

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

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

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

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

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

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

@@ -1,8 +0,0 @@
-import type { Transaction } from '@rocicorp/zero';
-import type { LabelSpecialUse } from '../../../types';
-import { type AuthData, type HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-import type { MarcoZeroSchema } from '../../../zero/schema';
-export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
-export declare const createThreadMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["thread"]>;
-//# sourceMappingURL=threadMutators.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAIhE,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,oBAAoB,cAAe,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA0O5G,CAAA"}