@zdavison/matador 4.1.0 → 4.2.0

package/dist/schema/types.test.js

@@ -1,246 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { MatadorEvent, createSubscriber, createSubscriberStub, } from '../types/index.js';
-import { bind, installPlugins, isSchemaEntryTuple } from './types.js';
-class UserCreatedEvent extends MatadorEvent {
-    data;
-    static key = 'user.created';
-    static description = 'User created event';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-class OrderPlacedEvent extends MatadorEvent {
-    data;
-    static key = 'order.placed';
-    static description = 'Order placed event';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-class ChatMessageSentEvent extends MatadorEvent {
-    data;
-    static key = 'chat.message.sent';
-    static description = 'Chat message sent event';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-describe('bind', () => {
-    it('should create a schema entry tuple', () => {
-        const subscriber = createSubscriber({
-            name: 'test-sub',
-            description: 'Test subscriber',
-            callback: async () => { },
-        });
-        const entry = bind(UserCreatedEvent, [subscriber]);
-        expect(isSchemaEntryTuple(entry)).toBe(true);
-        expect(entry[0]).toBe(UserCreatedEvent);
-        expect(entry[1]).toHaveLength(1);
-        expect(entry[1][0]).toBe(subscriber);
-    });
-});
-describe('isSchemaEntryTuple', () => {
-    it('should return true for tuple format', () => {
-        const entry = [UserCreatedEvent, []];
-        expect(isSchemaEntryTuple(entry)).toBe(true);
-    });
-    it('should return false for object format', () => {
-        const entry = { eventClass: UserCreatedEvent, subscribers: [] };
-        expect(isSchemaEntryTuple(entry)).toBe(false);
-    });
-});
-describe('installPlugins', () => {
-    it('should add plugin subscriber to all events', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const sub2 = createSubscriber({
-            name: 'order-handler',
-            description: 'Handles order events',
-            callback: async () => { },
-        });
-        const globalSub = createSubscriber({
-            name: 'analytics',
-            description: 'Analytics subscriber',
-            callback: async () => { },
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: [UserCreatedEvent, [sub1]],
-            [OrderPlacedEvent.key]: [OrderPlacedEvent, [sub2]],
-        };
-        const schema = installPlugins(baseSchema, [{ subscriber: globalSub }]);
-        // Check user.created has both subscribers
-        const userEntry = schema[UserCreatedEvent.key];
-        if (!userEntry)
-            throw new Error('expected user.created entry');
-        expect(isSchemaEntryTuple(userEntry)).toBe(true);
-        const [, userSubs] = userEntry;
-        expect(userSubs).toHaveLength(2);
-        expect(userSubs[0]).toBe(sub1);
-        expect(userSubs[1]).toBe(globalSub);
-        // Check order.placed has both subscribers
-        const orderEntry = schema[OrderPlacedEvent.key];
-        const [, orderSubs] = orderEntry;
-        expect(orderSubs).toHaveLength(2);
-        expect(orderSubs[0]).toBe(sub2);
-        expect(orderSubs[1]).toBe(globalSub);
-    });
-    it('should respect exclusions', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const sub2 = createSubscriber({
-            name: 'order-handler',
-            description: 'Handles order events',
-            callback: async () => { },
-        });
-        const sub3 = createSubscriber({
-            name: 'chat-handler',
-            description: 'Handles chat events',
-            callback: async () => { },
-        });
-        const globalSub = createSubscriber({
-            name: 'analytics',
-            description: 'Analytics subscriber',
-            callback: async () => { },
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: [UserCreatedEvent, [sub1]],
-            [OrderPlacedEvent.key]: [OrderPlacedEvent, [sub2]],
-            [ChatMessageSentEvent.key]: [ChatMessageSentEvent, [sub3]],
-        };
-        const schema = installPlugins(baseSchema, [
-            {
-                subscriber: globalSub,
-                exclusions: [ChatMessageSentEvent.key],
-            },
-        ]);
-        // user.created should have analytics
-        const userEntry = schema[UserCreatedEvent.key];
-        const [, userSubs] = userEntry;
-        expect(userSubs).toHaveLength(2);
-        // order.placed should have analytics
-        const orderEntry = schema[OrderPlacedEvent.key];
-        const [, orderSubs] = orderEntry;
-        expect(orderSubs).toHaveLength(2);
-        // chat.message.sent should NOT have analytics (excluded)
-        const chatEntry = schema[ChatMessageSentEvent.key];
-        const [, chatSubs] = chatEntry;
-        expect(chatSubs).toHaveLength(1);
-        expect(chatSubs[0]).toBe(sub3);
-    });
-    it('should handle multiple plugins', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const analyticsSub = createSubscriber({
-            name: 'analytics',
-            description: 'Analytics subscriber',
-            callback: async () => { },
-        });
-        const loggingSub = createSubscriber({
-            name: 'logging',
-            description: 'Logging subscriber',
-            callback: async () => { },
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: [UserCreatedEvent, [sub1]],
-        };
-        const schema = installPlugins(baseSchema, [
-            { subscriber: analyticsSub },
-            { subscriber: loggingSub },
-        ]);
-        const entry = schema[UserCreatedEvent.key];
-        const [, subs] = entry;
-        expect(subs).toHaveLength(3);
-        expect(subs[0]).toBe(sub1);
-        expect(subs[1]).toBe(analyticsSub);
-        expect(subs[2]).toBe(loggingSub);
-    });
-    it('should handle object format schema entries', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const globalSub = createSubscriber({
-            name: 'analytics',
-            description: 'Analytics subscriber',
-            callback: async () => { },
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: {
-                eventClass: UserCreatedEvent,
-                subscribers: [sub1],
-            },
-        };
-        const schema = installPlugins(baseSchema, [{ subscriber: globalSub }]);
-        const entry = schema[UserCreatedEvent.key];
-        if (!entry)
-            throw new Error('expected user.created entry');
-        expect(isSchemaEntryTuple(entry)).toBe(true);
-        const [eventClass, subs] = entry;
-        expect(eventClass).toBe(UserCreatedEvent);
-        expect(subs).toHaveLength(2);
-    });
-    it('should work with subscriber stubs', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const stubSub = createSubscriberStub({
-            name: 'remote-analytics',
-            targetQueue: 'analytics-worker',
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: [UserCreatedEvent, [sub1]],
-        };
-        const schema = installPlugins(baseSchema, [{ subscriber: stubSub }]);
-        const entry = schema[UserCreatedEvent.key];
-        const [, subs] = entry;
-        expect(subs).toHaveLength(2);
-        expect(subs[1]).toBe(stubSub);
-    });
-    it('should return empty schema for empty input', () => {
-        const schema = installPlugins({}, [
-            {
-                subscriber: createSubscriber({
-                    name: 'analytics',
-                    description: 'Analytics subscriber',
-                    callback: async () => { },
-                }),
-            },
-        ]);
-        expect(Object.keys(schema)).toHaveLength(0);
-    });
-    it('should not modify original schema', () => {
-        const sub1 = createSubscriber({
-            name: 'user-handler',
-            description: 'Handles user events',
-            callback: async () => { },
-        });
-        const globalSub = createSubscriber({
-            name: 'analytics',
-            description: 'Analytics subscriber',
-            callback: async () => { },
-        });
-        const baseSchema = {
-            [UserCreatedEvent.key]: [UserCreatedEvent, [sub1]],
-        };
-        installPlugins(baseSchema, [{ subscriber: globalSub }]);
-        // Original schema should be unchanged
-        const entry = baseSchema[UserCreatedEvent.key];
-        const [, subs] = entry;
-        expect(subs).toHaveLength(1);
-    });
-});

package/dist/topology/builder.test.d.ts

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

package/dist/topology/builder.test.d.ts.map

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