@zdavison/matador 2.0.1

package/dist/retry/index.d.ts

@@ -0,0 +1,4 @@
+export type { RetryContext, RetryDecision, RetryPolicy } from './policy.js';
+export type { StandardRetryPolicyConfig } from './standard-policy.js';
+export { defaultRetryConfig, StandardRetryPolicy } from './standard-policy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/retry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/retry/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5E,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/retry/index.js

@@ -0,0 +1 @@
+export { defaultRetryConfig, StandardRetryPolicy } from './standard-policy.js';

package/dist/retry/policy.d.ts

@@ -0,0 +1,43 @@
+import type { MessageReceipt } from '../transport/index.js';
+import type { Envelope, SubscriberDefinition } from '../types/index.js';
+/**
+ * Context provided to retry policy for decision making.
+ */
+export interface RetryContext {
+    /** The message envelope */
+    readonly envelope: Envelope;
+    /** The error that caused the failure */
+    readonly error: Error;
+    /** The subscriber definition */
+    readonly subscriber: SubscriberDefinition;
+    /** Message receipt with delivery information */
+    readonly receipt: MessageReceipt;
+}
+/**
+ * Decision returned by retry policy.
+ */
+export type RetryDecision = {
+    readonly action: 'retry';
+    readonly delay: number;
+} | {
+    readonly action: 'dead-letter';
+    readonly queue: string;
+    readonly reason: string;
+} | {
+    readonly action: 'discard';
+    readonly reason: string;
+};
+/**
+ * Interface for retry policies.
+ */
+export interface RetryPolicy {
+    /**
+     * Determines what to do with a failed message.
+     */
+    shouldRetry(context: RetryContext): RetryDecision;
+    /**
+     * Calculates the delay for a retry attempt.
+     */
+    getDelay(context: RetryContext): number;
+}
+//# sourceMappingURL=policy.d.ts.map

package/dist/retry/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/retry/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAEtB,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAE1C,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpD;IACE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC;CACzC"}

package/dist/retry/policy.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,44 @@
+import type { RetryContext, RetryDecision, RetryPolicy } from './policy.js';
+/**
+ * Configuration for the standard retry policy.
+ */
+export interface StandardRetryPolicyConfig {
+    /** Maximum number of attempts before dead-lettering */
+    readonly maxAttempts: number;
+    /** Base delay between retries in milliseconds */
+    readonly baseDelay: number;
+    /** Maximum delay between retries in milliseconds */
+    readonly maxDelay: number;
+    /** Multiplier for exponential backoff */
+    readonly backoffMultiplier: number;
+    /**
+     * Maximum native delivery count before considering message poisoned.
+     * This prevents crash loops from messages that crash the worker.
+     * Poison messages are sent directly to the dead-letter queue.
+     * Default: 5
+     */
+    readonly maxDeliveries: number;
+}
+/**
+ * Default configuration values.
+ */
+export declare const defaultRetryConfig: StandardRetryPolicyConfig;
+/**
+ * Standard retry policy implementing Matador v1 behavior.
+ *
+ * Decision logic (in priority order):
+ * 1. Poison message → dead-letter (prevent crash loops)
+ * 2. EventAssertionError → dead-letter (never retry)
+ * 3. DontRetry → dead-letter (explicit no-retry)
+ * 4. DoRetry → retry if under max attempts
+ * 5. Max attempts exceeded → dead-letter
+ * 6. Non-idempotent subscriber on redelivery → dead-letter
+ * 7. Default → retry with exponential backoff
+ */
+export declare class StandardRetryPolicy implements RetryPolicy {
+    private readonly config;
+    constructor(config?: Partial<StandardRetryPolicyConfig>);
+    shouldRetry(context: RetryContext): RetryDecision;
+    getDelay(context: RetryContext): number;
+}
+//# sourceMappingURL=standard-policy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard-policy.d.ts","sourceRoot":"","sources":["../../src/retry/standard-policy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,yCAAyC;IACzC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,yBAMhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;gBAEvC,MAAM,GAAE,OAAO,CAAC,yBAAyB,CAAM;IAI3D,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa;IAoFjD,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;CAOxC"}

package/dist/retry/standard-policy.js

@@ -0,0 +1,102 @@
+import { IdempotentMessageCannotRetryError, MessageMaybePoisonedError, isAssertionError, isDoRetry, isDontRetry, } from '../errors/index.js';
+/**
+ * Default configuration values.
+ */
+export const defaultRetryConfig = {
+    maxAttempts: 3,
+    baseDelay: 1000,
+    maxDelay: 300000, // 5 minutes
+    backoffMultiplier: 2,
+    maxDeliveries: 5,
+};
+/**
+ * Standard retry policy implementing Matador v1 behavior.
+ *
+ * Decision logic (in priority order):
+ * 1. Poison message → dead-letter (prevent crash loops)
+ * 2. EventAssertionError → dead-letter (never retry)
+ * 3. DontRetry → dead-letter (explicit no-retry)
+ * 4. DoRetry → retry if under max attempts
+ * 5. Max attempts exceeded → dead-letter
+ * 6. Non-idempotent subscriber on redelivery → dead-letter
+ * 7. Default → retry with exponential backoff
+ */
+export class StandardRetryPolicy {
+    config;
+    constructor(config = {}) {
+        this.config = { ...defaultRetryConfig, ...config };
+    }
+    shouldRetry(context) {
+        const { envelope, error, subscriber, receipt } = context;
+        const errorMessage = error.message;
+        // 1. Poison message detection - prevent crash loops
+        if (receipt.deliveryCount >= this.config.maxDeliveries) {
+            const poisonError = new MessageMaybePoisonedError(envelope.id, receipt.deliveryCount, this.config.maxDeliveries);
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: poisonError.message,
+            };
+        }
+        // 2. Assertion errors never retry
+        if (isAssertionError(error)) {
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: `assertion error: ${errorMessage}`,
+            };
+        }
+        // 3. Explicit no-retry
+        if (isDontRetry(error)) {
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: errorMessage,
+            };
+        }
+        // 4. Explicit retry request
+        if (isDoRetry(error)) {
+            if (receipt.attemptNumber >= this.config.maxAttempts) {
+                return {
+                    action: 'dead-letter',
+                    queue: 'undeliverable',
+                    reason: `max attempts exceeded (${this.config.maxAttempts}) with forced retry`,
+                };
+            }
+            return {
+                action: 'retry',
+                delay: this.getDelay(context),
+            };
+        }
+        // 5. Max attempts exceeded
+        if (receipt.attemptNumber >= this.config.maxAttempts) {
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: `max attempts exceeded (${this.config.maxAttempts})`,
+            };
+        }
+        // 6. Non-idempotent subscriber on redelivery
+        // 'no' and 'unknown' are treated the same (safer default)
+        if (receipt.redelivered &&
+            (subscriber.idempotent === 'no' || subscriber.idempotent === 'unknown')) {
+            const idempotentError = new IdempotentMessageCannotRetryError(envelope.id, subscriber.name);
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: idempotentError.message,
+            };
+        }
+        // 7. Default: retry with backoff
+        return {
+            action: 'retry',
+            delay: this.getDelay(context),
+        };
+    }
+    getDelay(context) {
+        const attempt = context.receipt.attemptNumber;
+        const delay = this.config.baseDelay *
+            Math.pow(this.config.backoffMultiplier, attempt - 1);
+        return Math.min(delay, this.config.maxDelay);
+    }
+}

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

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

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

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

@@ -0,0 +1,190 @@
+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 context = createContext(new EventAssertionError('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/index.d.ts

@@ -0,0 +1,4 @@
+export type { AnyEventClass, MatadorSchema, RegisterOptions, RuntimeSchemaEntry, RuntimeSchemaEntryTuple, SchemaEntry, SchemaEntryTuple, SchemaIssue, SchemaPlugin, SchemaValidationResult, } from './types.js';
+export { bind, installPlugins, isSchemaEntryTuple } from './types.js';
+export { SchemaError, SchemaRegistry } from './registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,uBAAuB,EACvB,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEtE,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/schema/index.js

@@ -0,0 +1,2 @@
+export { bind, installPlugins, isSchemaEntryTuple } from './types.js';
+export { SchemaError, SchemaRegistry } from './registry.js';

package/dist/schema/registry.d.ts

@@ -0,0 +1,63 @@
+import type { HasDescription } from '../errors/index.js';
+import type { AnySubscriber, EventClass, MatadorEvent, Subscriber, SubscriberDefinition } from '../types/index.js';
+import type { RegisterOptions, SchemaValidationResult } from './types.js';
+/**
+ * Error thrown when schema operations fail.
+ */
+export declare class SchemaError extends Error implements HasDescription {
+    readonly description: string;
+    constructor(message: string);
+}
+/**
+ * Registry for managing event-subscriber relationships.
+ */
+export declare class SchemaRegistry {
+    private readonly entries;
+    private readonly aliases;
+    /**
+     * Registers an event class with its subscribers.
+     */
+    register<T>(eventClass: EventClass<T>, subscribers: readonly AnySubscriber[], options?: RegisterOptions): void;
+    /**
+     * Gets the event class for a given key.
+     */
+    getEventClass(key: string): EventClass | undefined;
+    /**
+     * Gets all subscribers for an event key.
+     */
+    getSubscribers(eventKey: string): readonly AnySubscriber[];
+    /**
+     * Gets a specific subscriber by event key and subscriber name.
+     */
+    getSubscriber(eventKey: string, subscriberName: string): AnySubscriber | undefined;
+    /**
+     * Gets a subscriber definition for the pipeline.
+     */
+    getSubscriberDefinition(eventKey: string, subscriberName: string): SubscriberDefinition | undefined;
+    /**
+     * Gets a subscriber with callback for execution.
+     */
+    getExecutableSubscriber(eventKey: string, subscriberName: string): Subscriber<MatadorEvent<unknown>> | undefined;
+    /**
+     * Gets the event class by alias.
+     */
+    getEventByAlias(alias: string): EventClass | undefined;
+    /**
+     * Checks if an event key is registered.
+     */
+    hasEvent(key: string): boolean;
+    /**
+     * Gets all registered event keys.
+     */
+    getEventKeys(): readonly string[];
+    /**
+     * Validates the schema for issues.
+     */
+    validate(): SchemaValidationResult;
+    /**
+     * Clears all registered entries.
+     */
+    clear(): void;
+    private getEntry;
+}
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/schema/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EACV,eAAe,EAGf,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAM,YAAW,cAAc;IAC9D,QAAQ,CAAC,WAAW,SAIM;gBAEd,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD;;OAEG;IACH,QAAQ,CAAC,CAAC,EACR,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,WAAW,EAAE,SAAS,aAAa,EAAE,EACrC,OAAO,GAAE,eAAoB,GAC5B,IAAI;IA6BP;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAalD;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,aAAa,EAAE;IAK1D;;OAEG;IACH,aAAa,CACX,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACrB,aAAa,GAAG,SAAS;IAK5B;;OAEG;IACH,uBAAuB,CACrB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACrB,oBAAoB,GAAG,SAAS;IAkBnC;;OAEG;IACH,uBAAuB,CACrB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACrB,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS;IAMhD;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAMtD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI9B;;OAEG;IACH,YAAY,IAAI,SAAS,MAAM,EAAE;IAIjC;;OAEG;IACH,QAAQ,IAAI,sBAAsB;IAkClC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,QAAQ;CAWjB"}

package/dist/schema/registry.js

@@ -0,0 +1,171 @@
+import { isSubscriber } from '../types/index.js';
+/**
+ * Error thrown when schema operations fail.
+ */
+export class SchemaError extends Error {
+    description = 'A schema operation failed, such as registering a duplicate event or ' +
+        'conflicting alias. This is a configuration error that should be fixed ' +
+        'during development. Review the event and subscriber registrations to ' +
+        'resolve the conflict.';
+    constructor(message) {
+        super(message);
+        this.name = 'SchemaError';
+    }
+}
+/**
+ * Registry for managing event-subscriber relationships.
+ */
+export class SchemaRegistry {
+    entries = new Map();
+    aliases = new Map();
+    /**
+     * Registers an event class with its subscribers.
+     */
+    register(eventClass, subscribers, options = {}) {
+        const key = eventClass.key;
+        if (this.entries.has(key) && !options.override) {
+            throw new SchemaError(`Event "${key}" is already registered`);
+        }
+        this.entries.set(key, {
+            eventClass,
+            subscribers,
+        });
+        // Register aliases
+        if (eventClass.aliases) {
+            for (const alias of eventClass.aliases) {
+                if (this.aliases.has(alias) &&
+                    this.aliases.get(alias) !== key &&
+                    !options.override) {
+                    throw new SchemaError(`Alias "${alias}" is already registered for event "${this.aliases.get(alias)}"`);
+                }
+                this.aliases.set(alias, key);
+            }
+        }
+    }
+    /**
+     * Gets the event class for a given key.
+     */
+    getEventClass(key) {
+        const entry = this.entries.get(key);
+        if (entry)
+            return entry.eventClass;
+        // Check aliases
+        const aliasKey = this.aliases.get(key);
+        if (aliasKey) {
+            return this.entries.get(aliasKey)?.eventClass;
+        }
+        return undefined;
+    }
+    /**
+     * Gets all subscribers for an event key.
+     */
+    getSubscribers(eventKey) {
+        const entry = this.getEntry(eventKey);
+        return entry?.subscribers ?? [];
+    }
+    /**
+     * Gets a specific subscriber by event key and subscriber name.
+     */
+    getSubscriber(eventKey, subscriberName) {
+        const subscribers = this.getSubscribers(eventKey);
+        return subscribers.find((s) => s.name === subscriberName);
+    }
+    /**
+     * Gets a subscriber definition for the pipeline.
+     */
+    getSubscriberDefinition(eventKey, subscriberName) {
+        const subscriber = this.getSubscriber(eventKey, subscriberName);
+        if (!subscriber)
+            return undefined;
+        const def = {
+            name: subscriber.name,
+            description: subscriber.description,
+            idempotent: subscriber.idempotent ?? 'unknown',
+            importance: subscriber.importance ?? 'should-investigate',
+        };
+        if (subscriber.targetQueue !== undefined) {
+            def.targetQueue = subscriber.targetQueue;
+        }
+        return def;
+    }
+    /**
+     * Gets a subscriber with callback for execution.
+     */
+    getExecutableSubscriber(eventKey, subscriberName) {
+        const subscriber = this.getSubscriber(eventKey, subscriberName);
+        if (!subscriber || !isSubscriber(subscriber))
+            return undefined;
+        return subscriber;
+    }
+    /**
+     * Gets the event class by alias.
+     */
+    getEventByAlias(alias) {
+        const key = this.aliases.get(alias);
+        if (!key)
+            return undefined;
+        return this.entries.get(key)?.eventClass;
+    }
+    /**
+     * Checks if an event key is registered.
+     */
+    hasEvent(key) {
+        return this.entries.has(key) || this.aliases.has(key);
+    }
+    /**
+     * Gets all registered event keys.
+     */
+    getEventKeys() {
+        return [...this.entries.keys()];
+    }
+    /**
+     * Validates the schema for issues.
+     */
+    validate() {
+        const issues = [];
+        for (const [key, entry] of this.entries) {
+            // Check for duplicate subscriber names
+            const names = new Set();
+            for (const subscriber of entry.subscribers) {
+                if (names.has(subscriber.name)) {
+                    issues.push({
+                        severity: 'error',
+                        eventKey: key,
+                        message: `Duplicate subscriber name: "${subscriber.name}"`,
+                    });
+                }
+                names.add(subscriber.name);
+            }
+            // Check for subscribers without callbacks (stubs in consuming instance)
+            const stubs = entry.subscribers.filter((s) => !isSubscriber(s));
+            if (stubs.length === entry.subscribers.length && stubs.length > 0) {
+                issues.push({
+                    severity: 'warning',
+                    eventKey: key,
+                    message: 'All subscribers are stubs, no local handlers',
+                });
+            }
+        }
+        return {
+            valid: issues.filter((i) => i.severity === 'error').length === 0,
+            issues,
+        };
+    }
+    /**
+     * Clears all registered entries.
+     */
+    clear() {
+        this.entries.clear();
+        this.aliases.clear();
+    }
+    getEntry(eventKey) {
+        const entry = this.entries.get(eventKey);
+        if (entry)
+            return entry;
+        const aliasKey = this.aliases.get(eventKey);
+        if (aliasKey) {
+            return this.entries.get(aliasKey);
+        }
+        return undefined;
+    }
+}

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

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

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

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