@zdavison/matador 4.0.3 → 4.2.0

package/dist/retry/standard-policy.test.d.ts

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

package/dist/retry/standard-policy.test.d.ts.map

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

package/dist/retry/standard-policy.test.js

@@ -1,196 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { DoRetry, DontRetry, EventAssertionError, } from '../errors/retry-errors.js';
-import { createEnvelope } from '../types/envelope.js';
-import { StandardRetryPolicy } from './standard-policy.js';
-describe('StandardRetryPolicy', () => {
-    describe('shouldRetry', () => {
-        it('should dead-letter on EventAssertionError', () => {
-            const policy = new StandardRetryPolicy();
-            const envelope = createEnvelope({
-                eventKey: 'test.event',
-                targetSubscriber: 'test-subscriber',
-                data: { test: 'data' },
-                importance: 'should-investigate',
-            });
-            const context = createContext(new EventAssertionError(envelope, 'Invalid event'));
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.queue).toBe('undeliverable');
-            expect(decision.reason).toContain('assertion error');
-        });
-        it('should dead-letter on DontRetry error', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new DontRetry('Business rule violation'));
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.queue).toBe('undeliverable');
-            expect(decision.reason).toContain('Business rule violation');
-        });
-        it('should retry on DoRetry error if under max attempts', () => {
-            const policy = new StandardRetryPolicy({ maxAttempts: 3 });
-            const context = createContext(new DoRetry('Temporary failure'), {
-                attemptNumber: 1,
-            });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('retry');
-            assertRetry(decision);
-            expect(decision.delay).toBeGreaterThan(0);
-        });
-        it('should dead-letter on DoRetry error if max attempts exceeded', () => {
-            const policy = new StandardRetryPolicy({ maxAttempts: 3 });
-            const context = createContext(new DoRetry('Temporary failure'), {
-                attemptNumber: 3,
-            });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.reason).toContain('max attempts exceeded');
-        });
-        it('should dead-letter when max attempts exceeded', () => {
-            const policy = new StandardRetryPolicy({ maxAttempts: 3 });
-            const context = createContext(new Error('Generic error'), {
-                attemptNumber: 3,
-            });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.queue).toBe('undeliverable');
-            expect(decision.reason).toContain('max attempts exceeded (3)');
-        });
-        it('should dead-letter non-idempotent subscriber on redelivery', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new Error('Some error'), { attemptNumber: 1, redelivered: true }, { idempotent: 'no' });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.reason).toContain('Non-idempotent subscriber');
-        });
-        it('should retry idempotent subscriber on redelivery', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new Error('Some error'), { attemptNumber: 1, redelivered: true }, { idempotent: 'yes' });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('retry');
-        });
-        it('should dead-letter unknown idempotency subscriber on redelivery (unknown == no)', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new Error('Some error'), { attemptNumber: 1, redelivered: true }, { idempotent: 'unknown' });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-            assertDeadLetter(decision);
-            expect(decision.reason).toContain('Non-idempotent subscriber');
-        });
-        it('should retry resumable subscriber on redelivery', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new Error('Some error'), { attemptNumber: 1, redelivered: true }, { idempotent: 'resumable' });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('retry');
-        });
-        it('should retry generic errors with backoff', () => {
-            const policy = new StandardRetryPolicy({ maxAttempts: 5 });
-            const context = createContext(new Error('Generic error'), {
-                attemptNumber: 1,
-            });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('retry');
-            assertRetry(decision);
-            expect(decision.delay).toBeDefined();
-        });
-    });
-    describe('getDelay', () => {
-        it('should calculate exponential backoff', () => {
-            const policy = new StandardRetryPolicy({
-                baseDelay: 1000,
-                backoffMultiplier: 2,
-            });
-            const delay1 = policy.getDelay(createContext(new Error(), { attemptNumber: 1 }));
-            const delay2 = policy.getDelay(createContext(new Error(), { attemptNumber: 2 }));
-            const delay3 = policy.getDelay(createContext(new Error(), { attemptNumber: 3 }));
-            expect(delay1).toBe(1000); // 1000 * 2^0
-            expect(delay2).toBe(2000); // 1000 * 2^1
-            expect(delay3).toBe(4000); // 1000 * 2^2
-        });
-        it('should cap delay at maxDelay', () => {
-            const policy = new StandardRetryPolicy({
-                baseDelay: 1000,
-                backoffMultiplier: 10,
-                maxDelay: 5000,
-            });
-            const delay = policy.getDelay(createContext(new Error(), { attemptNumber: 5 }));
-            expect(delay).toBe(5000);
-        });
-    });
-    describe('configuration', () => {
-        it('should use default configuration', () => {
-            const policy = new StandardRetryPolicy();
-            const context = createContext(new Error(), { attemptNumber: 1 });
-            const decision = policy.shouldRetry(context);
-            // Default maxAttempts is 3, so should retry on attempt 1
-            expect(decision.action).toBe('retry');
-        });
-        it('should accept custom configuration', () => {
-            const policy = new StandardRetryPolicy({
-                maxAttempts: 1,
-                baseDelay: 500,
-                maxDelay: 1000,
-                backoffMultiplier: 1.5,
-            });
-            // With maxAttempts: 1, first attempt should dead-letter
-            const context = createContext(new Error(), { attemptNumber: 1 });
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('dead-letter');
-        });
-        it('should merge partial configuration with defaults', () => {
-            const policy = new StandardRetryPolicy({ maxAttempts: 10 });
-            // Use attemptNumber: 5 but deliveryCount: 3 to avoid poison detection
-            const context = createContext(new Error(), {
-                attemptNumber: 5,
-                deliveryCount: 3,
-            });
-            // Should still retry because we increased maxAttempts
-            const decision = policy.shouldRetry(context);
-            expect(decision.action).toBe('retry');
-        });
-    });
-});
-function assertDeadLetter(decision) {
-    if (decision.action !== 'dead-letter') {
-        throw new Error(`Expected dead-letter action, got ${decision.action}`);
-    }
-}
-function assertRetry(decision) {
-    if (decision.action !== 'retry') {
-        throw new Error(`Expected retry action, got ${decision.action}`);
-    }
-}
-function createContext(error, receiptOverrides = {}, subscriberOverrides = {}) {
-    const receipt = {
-        handle: {},
-        redelivered: false,
-        attemptNumber: 1,
-        deliveryCount: receiptOverrides.deliveryCount ?? receiptOverrides.attemptNumber ?? 1,
-        sourceQueue: 'test-queue',
-        sourceTransport: 'mock',
-        ...receiptOverrides,
-    };
-    const subscriber = {
-        name: 'test-subscriber',
-        description: 'Test subscriber',
-        idempotent: 'yes',
-        importance: 'should-investigate',
-        ...subscriberOverrides,
-    };
-    const envelope = createEnvelope({
-        eventKey: 'test.event',
-        targetSubscriber: 'test-subscriber',
-        data: { test: 'data' },
-        importance: 'should-investigate',
-    });
-    return {
-        envelope,
-        error,
-        receipt,
-        subscriber,
-    };
-}

package/dist/schema/registry.test.d.ts

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

package/dist/schema/registry.test.d.ts.map

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

package/dist/schema/registry.test.js

@@ -1,278 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test';
-import { MatadorEvent, createSubscriber } from '../types/index.js';
-import { SchemaError, SchemaRegistry } from './registry.js';
-class TestEvent extends MatadorEvent {
-    data;
-    static key = 'test.event';
-    static description = 'A test event';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-class AliasedEvent extends MatadorEvent {
-    data;
-    static key = 'user.created.v2';
-    static description = 'User created event with aliases';
-    static aliases = ['user.created', 'user.created.v1'];
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-describe('SchemaRegistry', () => {
-    let registry;
-    beforeEach(() => {
-        registry = new SchemaRegistry();
-    });
-    describe('register', () => {
-        it('should register an event with subscribers', () => {
-            const subscriber = createSubscriber({
-                name: 'test-subscriber',
-                description: 'Test subscriber',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [subscriber]);
-            expect(registry.hasEvent('test.event')).toBe(true);
-            expect(registry.getSubscribers('test.event')).toHaveLength(1);
-        });
-        it('should throw when registering duplicate event without override', () => {
-            const subscriber = createSubscriber({
-                name: 'test-subscriber',
-                description: 'Test subscriber',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [subscriber]);
-            expect(() => registry.register(TestEvent, [subscriber])).toThrow(SchemaError);
-        });
-        it('should allow override when option is set', () => {
-            const subscriber1 = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            const subscriber2 = createSubscriber({
-                name: 'sub-2',
-                description: 'Subscriber 2',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [subscriber1]);
-            registry.register(TestEvent, [subscriber2], { override: true });
-            const subscribers = registry.getSubscribers('test.event');
-            expect(subscribers).toHaveLength(1);
-            expect(subscribers[0]?.name).toBe('sub-2');
-        });
-        it('should register aliases', () => {
-            const subscriber = createSubscriber({
-                name: 'test-subscriber',
-                description: 'Test subscriber',
-                callback: async () => { },
-            });
-            registry.register(AliasedEvent, [subscriber]);
-            expect(registry.hasEvent('user.created.v2')).toBe(true);
-            expect(registry.hasEvent('user.created')).toBe(true);
-            expect(registry.hasEvent('user.created.v1')).toBe(true);
-        });
-        it('should throw on duplicate aliases without override', () => {
-            class EventWithSameAlias extends MatadorEvent {
-                data;
-                static key = 'another.event';
-                static description = 'Another event';
-                static aliases = ['user.created']; // conflicts with AliasedEvent
-                constructor(data) {
-                    super();
-                    this.data = data;
-                }
-            }
-            const sub1 = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            const sub2 = createSubscriber({
-                name: 'sub-2',
-                description: 'Subscriber 2',
-                callback: async () => { },
-            });
-            registry.register(AliasedEvent, [sub1]);
-            expect(() => registry.register(EventWithSameAlias, [sub2])).toThrow('Alias "user.created" is already registered');
-        });
-    });
-    describe('getEventClass', () => {
-        it('should return event class by key', () => {
-            const subscriber = createSubscriber({
-                name: 'test-subscriber',
-                description: 'Test subscriber',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [subscriber]);
-            const eventClass = registry.getEventClass('test.event');
-            expect(eventClass).toBeDefined();
-            expect(eventClass?.key).toBe('test.event');
-        });
-        it('should return event class by alias', () => {
-            const subscriber = createSubscriber({
-                name: 'test-subscriber',
-                description: 'Test subscriber',
-                callback: async () => { },
-            });
-            registry.register(AliasedEvent, [subscriber]);
-            const eventClass = registry.getEventClass('user.created');
-            expect(eventClass).toBeDefined();
-            expect(eventClass?.key).toBe('user.created.v2');
-        });
-        it('should return undefined for unknown key', () => {
-            expect(registry.getEventClass('unknown.event')).toBeUndefined();
-        });
-    });
-    describe('getSubscribers', () => {
-        it('should return all subscribers for an event', () => {
-            const sub1 = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            const sub2 = createSubscriber({
-                name: 'sub-2',
-                description: 'Subscriber 2',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub1, sub2]);
-            const subscribers = registry.getSubscribers('test.event');
-            expect(subscribers).toHaveLength(2);
-            expect(subscribers[0]?.name).toBe('sub-1');
-            expect(subscribers[1]?.name).toBe('sub-2');
-        });
-        it('should return empty array for unknown event', () => {
-            expect(registry.getSubscribers('unknown.event')).toEqual([]);
-        });
-    });
-    describe('getSubscriber', () => {
-        it('should return specific subscriber by name', () => {
-            const sub1 = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            const sub2 = createSubscriber({
-                name: 'sub-2',
-                description: 'Subscriber 2',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub1, sub2]);
-            const subscriber = registry.getSubscriber('test.event', 'sub-2');
-            expect(subscriber?.name).toBe('sub-2');
-        });
-        it('should return undefined for unknown subscriber', () => {
-            const sub = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub]);
-            expect(registry.getSubscriber('test.event', 'unknown')).toBeUndefined();
-        });
-    });
-    describe('getSubscriberDefinition', () => {
-        it('should return subscriber definition for pipeline', () => {
-            const sub = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-                idempotent: 'yes',
-                importance: 'must-investigate',
-                targetQueue: 'custom-queue',
-            });
-            registry.register(TestEvent, [sub]);
-            const definition = registry.getSubscriberDefinition('test.event', 'sub-1');
-            expect(definition).toEqual({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                idempotent: 'yes',
-                importance: 'must-investigate',
-                targetQueue: 'custom-queue',
-            });
-        });
-        it('should return undefined for unknown subscriber', () => {
-            expect(registry.getSubscriberDefinition('unknown', 'unknown')).toBeUndefined();
-        });
-    });
-    describe('getExecutableSubscriber', () => {
-        it('should return subscriber with callback', () => {
-            const callback = async () => { };
-            const sub = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback,
-            });
-            registry.register(TestEvent, [sub]);
-            const executable = registry.getExecutableSubscriber('test.event', 'sub-1');
-            expect(executable).toBeDefined();
-            expect(executable?.callback).toBe(callback);
-        });
-    });
-    describe('getEventKeys', () => {
-        it('should return all registered event keys', () => {
-            const sub1 = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            const sub2 = createSubscriber({
-                name: 'sub-2',
-                description: 'Subscriber 2',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub1]);
-            registry.register(AliasedEvent, [sub2]);
-            const keys = registry.getEventKeys();
-            expect(keys).toContain('test.event');
-            expect(keys).toContain('user.created.v2');
-            expect(keys).not.toContain('user.created'); // aliases not included
-        });
-    });
-    describe('validate', () => {
-        it('should pass validation for valid schema', () => {
-            const sub = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub]);
-            const result = registry.validate();
-            expect(result.valid).toBe(true);
-            expect(result.issues).toHaveLength(0);
-        });
-        it('should detect duplicate subscriber names', () => {
-            const sub1 = createSubscriber({
-                name: 'duplicate-name',
-                description: 'Duplicate subscriber',
-                callback: async () => { },
-            });
-            const sub2 = createSubscriber({
-                name: 'duplicate-name',
-                description: 'Duplicate subscriber',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub1, sub2]);
-            const result = registry.validate();
-            expect(result.valid).toBe(false);
-            expect(result.issues).toHaveLength(1);
-            expect(result.issues[0]?.severity).toBe('error');
-            expect(result.issues[0]?.message).toContain('Duplicate subscriber name');
-        });
-    });
-    describe('clear', () => {
-        it('should remove all entries', () => {
-            const sub = createSubscriber({
-                name: 'sub-1',
-                description: 'Subscriber 1',
-                callback: async () => { },
-            });
-            registry.register(TestEvent, [sub]);
-            registry.clear();
-            expect(registry.hasEvent('test.event')).toBe(false);
-            expect(registry.getEventKeys()).toHaveLength(0);
-        });
-    });
-});

package/dist/schema/types.test.d.ts

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

package/dist/schema/types.test.d.ts.map

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