@zdavison/matador 4.1.0 → 4.2.0

package/dist/checkpoint/stores/stores.test.js

@@ -1,146 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test';
-import { MemoryCheckpointStore } from './memory.js';
-import { NoOpCheckpointStore } from './noop.js';
-describe('MemoryCheckpointStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new MemoryCheckpointStore();
-    });
-    describe('get()', () => {
-        it('should return undefined for non-existent checkpoint', async () => {
-            const result = await store.get('non-existent');
-            expect(result).toBeUndefined();
-        });
-        it('should return stored checkpoint', async () => {
-            const checkpoint = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: { 'step-1': 'result-1' },
-            };
-            await store.set('test-id', checkpoint);
-            const result = await store.get('test-id');
-            expect(result).toEqual(checkpoint);
-        });
-    });
-    describe('set()', () => {
-        it('should store checkpoint', async () => {
-            const checkpoint = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: {},
-            };
-            await store.set('test-id', checkpoint);
-            expect(store.size).toBe(1);
-        });
-        it('should overwrite existing checkpoint', async () => {
-            const checkpoint1 = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: { 'step-1': 'old' },
-            };
-            const checkpoint2 = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: { 'step-1': 'new', 'step-2': 'added' },
-            };
-            await store.set('test-id', checkpoint1);
-            await store.set('test-id', checkpoint2);
-            const result = await store.get('test-id');
-            expect(result).toEqual(checkpoint2);
-            expect(store.size).toBe(1);
-        });
-    });
-    describe('delete()', () => {
-        it('should delete checkpoint', async () => {
-            const checkpoint = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: {},
-            };
-            await store.set('test-id', checkpoint);
-            expect(store.size).toBe(1);
-            await store.delete('test-id');
-            expect(store.size).toBe(0);
-        });
-        it('should not throw when deleting non-existent checkpoint', async () => {
-            await expect(store.delete('non-existent')).resolves.toBeUndefined();
-        });
-    });
-    describe('utility methods', () => {
-        it('size should return number of checkpoints', async () => {
-            expect(store.size).toBe(0);
-            await store.set('id-1', {
-                envelopeId: 'id-1',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            expect(store.size).toBe(1);
-            await store.set('id-2', {
-                envelopeId: 'id-2',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            expect(store.size).toBe(2);
-        });
-        it('clear() should remove all checkpoints', async () => {
-            await store.set('id-1', {
-                envelopeId: 'id-1',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            await store.set('id-2', {
-                envelopeId: 'id-2',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            expect(store.size).toBe(2);
-            store.clear();
-            expect(store.size).toBe(0);
-        });
-        it('keys() should return all checkpoint IDs', async () => {
-            await store.set('id-1', {
-                envelopeId: 'id-1',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            await store.set('id-2', {
-                envelopeId: 'id-2',
-                subscriberName: 'sub',
-                completedSteps: {},
-            });
-            const keys = store.keys();
-            expect(keys).toContain('id-1');
-            expect(keys).toContain('id-2');
-            expect(keys).toHaveLength(2);
-        });
-    });
-});
-describe('NoOpCheckpointStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new NoOpCheckpointStore();
-    });
-    describe('get()', () => {
-        it('should always return undefined', async () => {
-            const result = await store.get('any-id');
-            expect(result).toBeUndefined();
-        });
-    });
-    describe('set()', () => {
-        it('should not store anything (no-op)', async () => {
-            const checkpoint = {
-                envelopeId: 'test-id',
-                subscriberName: 'test-subscriber',
-                completedSteps: { 'step-1': 'result-1' },
-            };
-            await store.set('test-id', checkpoint);
-            const result = await store.get('test-id');
-            expect(result).toBeUndefined();
-        });
-    });
-    describe('delete()', () => {
-        it('should not throw', async () => {
-            await expect(store.delete('any-id')).resolves.toBeUndefined();
-        });
-    });
-});

package/dist/codec/rabbitmq-codec.test.d.ts

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

package/dist/codec/rabbitmq-codec.test.d.ts.map

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

package/dist/codec/rabbitmq-codec.test.js

@@ -1,428 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { RabbitMQCodec } from './rabbitmq-codec.js';
-/**
- * Add your v1 message examples here.
- * Each fixture describes:
- * - name: A descriptive name for the test case
- * - body: The v1 message body (what goes in the RabbitMQ message content)
- * - headers: Optional RabbitMQ headers that accompany the message
- * - expected: The expected v2 envelope fields after translation
- */
-const V1_MESSAGE_FIXTURES = [
-    // === BASIC EXAMPLES ===
-    {
-        name: 'minimal v1 message with only required fields',
-        body: {
-            key: 'user.created',
-            data: { userId: '123' },
-            targetSubscriber: 'email-service',
-        },
-        expected: {
-            eventKey: 'user.created',
-            targetSubscriber: 'email-service',
-            data: { userId: '123' },
-            attempts: 1,
-            importance: 'should-investigate',
-        },
-    },
-    {
-        name: 'v1 message with metadata',
-        body: {
-            key: 'order.placed',
-            data: { orderId: 'ORD-456', amount: 99.99 },
-            metadata: { source: 'web', region: 'us-east' },
-            targetSubscriber: 'fulfillment-service',
-        },
-        expected: {
-            eventKey: 'order.placed',
-            targetSubscriber: 'fulfillment-service',
-            data: { orderId: 'ORD-456', amount: 99.99 },
-            metadata: { source: 'web', region: 'us-east' },
-        },
-    },
-    // === UNIVERSAL METADATA EXAMPLES ===
-    {
-        name: 'v1 message with universal.event_id',
-        body: {
-            key: 'payment.processed',
-            data: { paymentId: 'PAY-789' },
-            universal: {
-                event_id: 'evt-abc-123',
-            },
-            targetSubscriber: 'notification-service',
-        },
-        expected: {
-            id: 'evt-abc-123',
-            eventKey: 'payment.processed',
-            targetSubscriber: 'notification-service',
-            data: { paymentId: 'PAY-789' },
-        },
-    },
-    {
-        name: 'v1 message with universal.user_id (merged into metadata)',
-        body: {
-            key: 'profile.updated',
-            data: { field: 'email' },
-            universal: {
-                user_id: 'user-456',
-            },
-            targetSubscriber: 'audit-service',
-        },
-        expected: {
-            eventKey: 'profile.updated',
-            targetSubscriber: 'audit-service',
-            data: { field: 'email' },
-            metadata: { user_id: 'user-456' },
-        },
-    },
-    {
-        name: 'v1 message with universal.correlation_id',
-        body: {
-            key: 'request.received',
-            data: { requestId: 'req-001' },
-            universal: {
-                correlation_id: 'corr-xyz-789',
-            },
-            targetSubscriber: 'logger-service',
-        },
-        expected: {
-            eventKey: 'request.received',
-            targetSubscriber: 'logger-service',
-            data: { requestId: 'req-001' },
-            correlationId: 'corr-xyz-789',
-        },
-    },
-    {
-        name: 'v1 message with all universal fields',
-        body: {
-            key: 'checkout.completed',
-            data: { cartId: 'cart-999' },
-            universal: {
-                event_id: 'evt-full-123',
-                user_id: 'user-777',
-                correlation_id: 'corr-full-456',
-                custom_field: 'custom_value',
-            },
-            targetSubscriber: 'analytics-service',
-        },
-        expected: {
-            id: 'evt-full-123',
-            eventKey: 'checkout.completed',
-            targetSubscriber: 'analytics-service',
-            data: { cartId: 'cart-999' },
-            correlationId: 'corr-full-456',
-            metadata: {
-                user_id: 'user-777',
-                custom_field: 'custom_value',
-            },
-        },
-    },
-    // === METADATA MERGING EXAMPLES ===
-    {
-        name: 'v1 message with both metadata and universal (merged)',
-        body: {
-            key: 'item.added',
-            data: { itemId: 'item-123' },
-            metadata: { category: 'electronics', priority: 'high' },
-            universal: {
-                user_id: 'user-888',
-                tenant_id: 'tenant-001',
-            },
-            targetSubscriber: 'inventory-service',
-        },
-        expected: {
-            eventKey: 'item.added',
-            targetSubscriber: 'inventory-service',
-            data: { itemId: 'item-123' },
-            metadata: {
-                category: 'electronics',
-                priority: 'high',
-                user_id: 'user-888',
-                tenant_id: 'tenant-001',
-            },
-        },
-    },
-    // === HEADER-BASED EXAMPLES ===
-    {
-        name: 'v1 message with attempt count from header',
-        body: {
-            key: 'task.retry',
-            data: { taskId: 'task-555' },
-            targetSubscriber: 'worker-service',
-        },
-        headers: {
-            'x-matador-attempts': 3,
-        },
-        expected: {
-            eventKey: 'task.retry',
-            targetSubscriber: 'worker-service',
-            data: { taskId: 'task-555' },
-            attempts: 3,
-        },
-    },
-    {
-        name: 'v1 message with importance from header',
-        body: {
-            key: 'alert.triggered',
-            data: { alertId: 'alert-111' },
-            targetSubscriber: 'pager-service',
-        },
-        headers: {
-            'x-matador-importance': 'must-investigate',
-        },
-        expected: {
-            eventKey: 'alert.triggered',
-            targetSubscriber: 'pager-service',
-            data: { alertId: 'alert-111' },
-            importance: 'must-investigate',
-        },
-    },
-    {
-        name: 'v1 message with correlation_id from v1 header',
-        body: {
-            key: 'trace.event',
-            data: { traceId: 'trace-222' },
-            targetSubscriber: 'tracing-service',
-        },
-        headers: {
-            'x-correlation-id': 'header-corr-id',
-        },
-        expected: {
-            eventKey: 'trace.event',
-            targetSubscriber: 'tracing-service',
-            data: { traceId: 'trace-222' },
-            correlationId: 'header-corr-id',
-        },
-    },
-    {
-        name: 'v1 message with event_id from v1 header',
-        body: {
-            key: 'legacy.event',
-            data: { legacyId: 'leg-333' },
-            targetSubscriber: 'legacy-handler',
-        },
-        headers: {
-            'x-event-id': 'header-event-id-456',
-        },
-        expected: {
-            id: 'header-event-id-456',
-            eventKey: 'legacy.event',
-            targetSubscriber: 'legacy-handler',
-            data: { legacyId: 'leg-333' },
-        },
-    },
-    // === EDGE CASES ===
-    {
-        name: 'v1 message with null universal fields (ignored)',
-        body: {
-            key: 'null.test',
-            data: { test: true },
-            universal: {
-                event_id: null,
-                user_id: null,
-                correlation_id: null,
-            },
-            targetSubscriber: 'null-handler',
-        },
-        expected: {
-            eventKey: 'null.test',
-            targetSubscriber: 'null-handler',
-            data: { test: true },
-        },
-    },
-    {
-        name: 'v1 message with empty metadata object',
-        body: {
-            key: 'empty.metadata',
-            data: { value: 42 },
-            metadata: {},
-            targetSubscriber: 'empty-handler',
-        },
-        expected: {
-            eventKey: 'empty.metadata',
-            targetSubscriber: 'empty-handler',
-            data: { value: 42 },
-        },
-    },
-    {
-        name: 'v1 message with complex nested data',
-        body: {
-            key: 'complex.event',
-            data: {
-                nested: {
-                    deeply: {
-                        value: [1, 2, { three: 'four' }],
-                    },
-                },
-                array: ['a', 'b', 'c'],
-            },
-            targetSubscriber: 'complex-handler',
-        },
-        expected: {
-            eventKey: 'complex.event',
-            targetSubscriber: 'complex-handler',
-            data: {
-                nested: {
-                    deeply: {
-                        value: [1, 2, { three: 'four' }],
-                    },
-                },
-                array: ['a', 'b', 'c'],
-            },
-        },
-    },
-    {
-        name: 'v1 message with before field (ignored in v2)',
-        body: {
-            key: 'update.event',
-            data: { newValue: 'after' },
-            before: { oldValue: 'before' },
-            targetSubscriber: 'update-handler',
-        },
-        expected: {
-            eventKey: 'update.event',
-            targetSubscriber: 'update-handler',
-            data: { newValue: 'after' },
-        },
-    },
-    // === ADD YOUR EXAMPLES BELOW ===
-    // Copy this template and fill in your v1 message data:
-    //
-    // {
-    //   name: 'descriptive name for your test case',
-    //   body: {
-    //     key: 'your.event.key',
-    //     data: { /* your event data */ },
-    //     metadata: { /* optional metadata */ },
-    //     universal: {
-    //       event_id: 'optional-event-id',
-    //       user_id: 'optional-user-id',
-    //       correlation_id: 'optional-correlation-id',
-    //       // any other custom fields
-    //     },
-    //     before: { /* optional, will be ignored */ },
-    //     options: { delayMs: 1000 }, // optional
-    //     targetSubscriber: 'your-subscriber-name',
-    //   },
-    //   headers: {
-    //     // optional headers
-    //     'x-matador-attempts': 1,
-    //     'x-matador-importance': 'should-investigate',
-    //     'x-event-id': 'header-event-id',
-    //     'x-correlation-id': 'header-correlation-id',
-    //   },
-    //   expected: {
-    //     id: 'expected-id', // optional, will be generated if not in body/headers
-    //     eventKey: 'your.event.key',
-    //     targetSubscriber: 'your-subscriber-name',
-    //     data: { /* expected data */ },
-    //     metadata: { /* expected merged metadata */ },
-    //     correlationId: 'expected-correlation-id',
-    //     attempts: 1,
-    //     importance: 'should-investigate',
-    //   },
-    // },
-];
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
-function assertV1Id(envelope, expectedId) {
-    if (expectedId !== undefined) {
-        expect(envelope.id).toBe(expectedId);
-    }
-    else {
-        expect(envelope.id).toMatch(UUID_PATTERN);
-    }
-}
-function assertV1Metadata(metadata, expected) {
-    if (expected !== undefined) {
-        expect(metadata).toEqual(expected);
-    }
-    else {
-        expect(metadata === undefined || Object.keys(metadata).length === 0).toBe(true);
-    }
-}
-function assertV1Translation(envelope, expected) {
-    expect(envelope.docket.eventKey).toBe(expected.eventKey);
-    expect(envelope.docket.targetSubscriber).toBe(expected.targetSubscriber);
-    expect(envelope.data).toEqual(expected.data);
-    assertV1Id(envelope, expected.id);
-    assertV1Metadata(envelope.docket.metadata, expected.metadata);
-    if (expected.correlationId !== undefined) {
-        expect(envelope.docket.correlationId).toBe(expected.correlationId);
-    }
-    expect(envelope.docket.attempts).toBe(expected.attempts ?? 1);
-    expect(envelope.docket.importance).toBe(expected.importance ?? 'should-investigate');
-    expect(envelope.docket.createdAt).toMatch(ISO_DATE_PATTERN);
-}
-describe('RabbitMQCodec', () => {
-    const codec = new RabbitMQCodec();
-    describe('v1 to v2 translation', () => {
-        for (const fixture of V1_MESSAGE_FIXTURES) {
-            it(`should translate: ${fixture.name}`, () => {
-                const body = new TextEncoder().encode(JSON.stringify(fixture.body));
-                const headers = fixture.headers ?? {};
-                const envelope = codec.decode(body, headers);
-                assertV1Translation(envelope, fixture.expected);
-            });
-        }
-    });
-    describe('v1 edge cases', () => {
-        it('should handle options.delayMs by setting scheduledFor', () => {
-            const body = {
-                key: 'delayed.event',
-                data: { test: true },
-                options: { delayMs: 5000 },
-                targetSubscriber: 'delay-handler',
-            };
-            const encoded = new TextEncoder().encode(JSON.stringify(body));
-            const before = Date.now();
-            const envelope = codec.decode(encoded, {});
-            const after = Date.now();
-            const { scheduledFor } = envelope.docket;
-            if (!scheduledFor)
-                throw new Error('expected scheduledFor to be set');
-            const scheduledTime = new Date(scheduledFor).getTime();
-            expect(scheduledTime).toBeGreaterThanOrEqual(before + 5000);
-            expect(scheduledTime).toBeLessThanOrEqual(after + 5000);
-        });
-        it('should prefer header event_id over body universal.event_id', () => {
-            const body = {
-                key: 'priority.test',
-                data: {},
-                universal: { event_id: 'body-event-id' },
-                targetSubscriber: 'test-handler',
-            };
-            const encoded = new TextEncoder().encode(JSON.stringify(body));
-            const envelope = codec.decode(encoded, {
-                'x-event-id': 'header-event-id',
-            });
-            expect(envelope.id).toBe('header-event-id');
-        });
-        it('should prefer v2 correlation header over v1 header', () => {
-            const body = {
-                key: 'corr.priority',
-                data: {},
-                targetSubscriber: 'test-handler',
-            };
-            const encoded = new TextEncoder().encode(JSON.stringify(body));
-            const envelope = codec.decode(encoded, {
-                'x-matador-correlation-id': 'v2-corr-id',
-                'x-correlation-id': 'v1-corr-id',
-            });
-            expect(envelope.docket.correlationId).toBe('v2-corr-id');
-        });
-        it('should prefer header correlation_id over body universal.correlation_id', () => {
-            const body = {
-                key: 'corr.priority',
-                data: {},
-                universal: { correlation_id: 'body-corr-id' },
-                targetSubscriber: 'test-handler',
-            };
-            const encoded = new TextEncoder().encode(JSON.stringify(body));
-            const envelope = codec.decode(encoded, {
-                'x-correlation-id': 'header-corr-id',
-            });
-            expect(envelope.docket.correlationId).toBe('header-corr-id');
-        });
-    });
-});

package/dist/core/fanout.test.d.ts

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

package/dist/core/fanout.test.d.ts.map

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