@geekmidas/events 0.1.0 → 0.2.0

package/src/basic/BasicConnection.ts

@@ -3,45 +3,45 @@ import type { EventConnection } from '../types';
 import { EventPublisherType } from '../types';
 
 export class BasicConnection implements EventConnection {
-  readonly type = EventPublisherType.Basic;
-  private emitter: EventEmitter;
-  private connected = false;
+	readonly type = EventPublisherType.Basic;
+	private emitter: EventEmitter;
+	private connected = false;
 
-  constructor() {
-    this.emitter = new EventEmitter();
-  }
+	constructor() {
+		this.emitter = new EventEmitter();
+	}
 
-  /**
-   * Create a BasicConnection from a connection string
-   * Format: basic://
-   */
-  static async fromConnectionString(
-    _connectionString: string,
-  ): Promise<BasicConnection> {
-    // Basic connection doesn't need any configuration
-    const connection = new BasicConnection();
-    await connection.connect();
-    return connection;
-  }
+	/**
+	 * Create a BasicConnection from a connection string
+	 * Format: basic://
+	 */
+	static async fromConnectionString(
+		_connectionString: string,
+	): Promise<BasicConnection> {
+		// Basic connection doesn't need any configuration
+		const connection = new BasicConnection();
+		await connection.connect();
+		return connection;
+	}
 
-  async connect(): Promise<void> {
-    this.connected = true;
-  }
+	async connect(): Promise<void> {
+		this.connected = true;
+	}
 
-  async close(): Promise<void> {
-    this.emitter.removeAllListeners();
-    this.connected = false;
-  }
+	async close(): Promise<void> {
+		this.emitter.removeAllListeners();
+		this.connected = false;
+	}
 
-  isConnected(): boolean {
-    return this.connected;
-  }
+	isConnected(): boolean {
+		return this.connected;
+	}
 
-  /**
-   * Get the underlying EventEmitter
-   * Used by BasicPublisher and BasicSubscriber
-   */
-  get eventEmitter(): EventEmitter {
-    return this.emitter;
-  }
+	/**
+	 * Get the underlying EventEmitter
+	 * Used by BasicPublisher and BasicSubscriber
+	 */
+	get eventEmitter(): EventEmitter {
+		return this.emitter;
+	}
 }

package/src/basic/BasicPublisher.ts

@@ -2,14 +2,14 @@ import type { EventPublisher, PublishableMessage } from '../types';
 import type { BasicConnection } from './BasicConnection';
 
 export class BasicPublisher<TMessage extends PublishableMessage<string, any>>
-  implements EventPublisher<TMessage>
+	implements EventPublisher<TMessage>
 {
-  constructor(private connection: BasicConnection) {}
+	constructor(private connection: BasicConnection) {}
 
-  async publish(messages: TMessage[]) {
-    const emitter = this.connection.eventEmitter;
-    for (const message of messages) {
-      emitter.emit(message.type, message);
-    }
-  }
+	async publish(messages: TMessage[]) {
+		const emitter = this.connection.eventEmitter;
+		for (const message of messages) {
+			emitter.emit(message.type, message);
+		}
+	}
 }

package/src/basic/BasicSubscriber.ts

@@ -2,23 +2,20 @@ import type { EventSubscriber, PublishableMessage } from '../types';
 import type { BasicConnection } from './BasicConnection';
 
 export class BasicSubscriber<TMessage extends PublishableMessage<string, any>>
-  implements EventSubscriber<TMessage>
+	implements EventSubscriber<TMessage>
 {
-  constructor(private connection: BasicConnection) {}
+	constructor(private connection: BasicConnection) {}
 
-  async subscribe(
-    messages: TMessage['type'][],
-    listener: (payload: TMessage) => Promise<void>,
-  ): Promise<void> {
-    const emitter = this.connection.eventEmitter;
+	async subscribe(
+		messages: TMessage['type'][],
+		listener: (payload: TMessage) => Promise<void>,
+	): Promise<void> {
+		const emitter = this.connection.eventEmitter;
 
-    for (const messageType of messages) {
-      emitter.on(messageType, (message: TMessage) => {
-        listener(message).catch((error) => {
-          // Log error but don't throw to prevent unhandled promise rejections
-          console.error(`Error processing message ${messageType}:`, error);
-        });
-      });
-    }
-  }
+		for (const messageType of messages) {
+			emitter.on(messageType, (message: TMessage) => {
+				listener(message).catch((_error) => {});
+			});
+		}
+	}
 }

package/src/basic/__tests__/BasicSubscriber.spec.ts

@@ -7,160 +7,160 @@ import { BasicSubscriber } from '../BasicSubscriber';
 type TestMessage = PublishableMessage<'user.created' | 'user.updated', any>;
 
 describe('BasicSubscriber', () => {
-  it('should receive published messages', async () => {
-    const connection = new BasicConnection();
-    await connection.connect();
+	it('should receive published messages', async () => {
+		const connection = new BasicConnection();
+		await connection.connect();
 
-    const publisher = new BasicPublisher<TestMessage>(connection);
-    const subscriber = new BasicSubscriber<TestMessage>(connection);
+		const publisher = new BasicPublisher<TestMessage>(connection);
+		const subscriber = new BasicSubscriber<TestMessage>(connection);
 
-    const receivedMessages: TestMessage[] = [];
+		const receivedMessages: TestMessage[] = [];
 
-    await subscriber.subscribe(['user.created'], async (message) => {
-      receivedMessages.push(message);
-    });
+		await subscriber.subscribe(['user.created'], async (message) => {
+			receivedMessages.push(message);
+		});
 
-    await publisher.publish([
-      { type: 'user.created', payload: { userId: '123' } },
-    ]);
+		await publisher.publish([
+			{ type: 'user.created', payload: { userId: '123' } },
+		]);
 
-    // Give event emitter time to process
-    await new Promise((resolve) => setTimeout(resolve, 10));
+		// Give event emitter time to process
+		await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(receivedMessages).toHaveLength(1);
-    expect(receivedMessages[0]).toEqual({
-      type: 'user.created',
-      payload: { userId: '123' },
-    });
+		expect(receivedMessages).toHaveLength(1);
+		expect(receivedMessages[0]).toEqual({
+			type: 'user.created',
+			payload: { userId: '123' },
+		});
 
-    await connection.close();
-  });
+		await connection.close();
+	});
 
-  it('should receive multiple message types', async () => {
-    const connection = new BasicConnection();
-    await connection.connect();
+	it('should receive multiple message types', async () => {
+		const connection = new BasicConnection();
+		await connection.connect();
 
-    const publisher = new BasicPublisher<TestMessage>(connection);
-    const subscriber = new BasicSubscriber<TestMessage>(connection);
+		const publisher = new BasicPublisher<TestMessage>(connection);
+		const subscriber = new BasicSubscriber<TestMessage>(connection);
 
-    const receivedMessages: TestMessage[] = [];
+		const receivedMessages: TestMessage[] = [];
 
-    await subscriber.subscribe(
-      ['user.created', 'user.updated'],
-      async (message) => {
-        receivedMessages.push(message);
-      },
-    );
+		await subscriber.subscribe(
+			['user.created', 'user.updated'],
+			async (message) => {
+				receivedMessages.push(message);
+			},
+		);
 
-    await publisher.publish([
-      { type: 'user.created', payload: { userId: '1' } },
-      { type: 'user.updated', payload: { userId: '2' } },
-      { type: 'user.created', payload: { userId: '3' } },
-    ]);
+		await publisher.publish([
+			{ type: 'user.created', payload: { userId: '1' } },
+			{ type: 'user.updated', payload: { userId: '2' } },
+			{ type: 'user.created', payload: { userId: '3' } },
+		]);
 
-    // Give event emitter time to process
-    await new Promise((resolve) => setTimeout(resolve, 10));
+		// Give event emitter time to process
+		await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(receivedMessages).toHaveLength(3);
-    expect(receivedMessages[0].type).toBe('user.created');
-    expect(receivedMessages[1].type).toBe('user.updated');
-    expect(receivedMessages[2].type).toBe('user.created');
+		expect(receivedMessages).toHaveLength(3);
+		expect(receivedMessages[0].type).toBe('user.created');
+		expect(receivedMessages[1].type).toBe('user.updated');
+		expect(receivedMessages[2].type).toBe('user.created');
 
-    await connection.close();
-  });
+		await connection.close();
+	});
 
-  it('should only receive subscribed message types', async () => {
-    const connection = new BasicConnection();
-    await connection.connect();
+	it('should only receive subscribed message types', async () => {
+		const connection = new BasicConnection();
+		await connection.connect();
 
-    const publisher = new BasicPublisher<TestMessage>(connection);
-    const subscriber = new BasicSubscriber<TestMessage>(connection);
+		const publisher = new BasicPublisher<TestMessage>(connection);
+		const subscriber = new BasicSubscriber<TestMessage>(connection);
 
-    const receivedMessages: TestMessage[] = [];
+		const receivedMessages: TestMessage[] = [];
 
-    // Only subscribe to user.created
-    await subscriber.subscribe(['user.created'], async (message) => {
-      receivedMessages.push(message);
-    });
+		// Only subscribe to user.created
+		await subscriber.subscribe(['user.created'], async (message) => {
+			receivedMessages.push(message);
+		});
 
-    await publisher.publish([
-      { type: 'user.created', payload: { userId: '1' } },
-      { type: 'user.updated', payload: { userId: '2' } },
-      { type: 'user.created', payload: { userId: '3' } },
-    ]);
+		await publisher.publish([
+			{ type: 'user.created', payload: { userId: '1' } },
+			{ type: 'user.updated', payload: { userId: '2' } },
+			{ type: 'user.created', payload: { userId: '3' } },
+		]);
 
-    // Give event emitter time to process
-    await new Promise((resolve) => setTimeout(resolve, 10));
+		// Give event emitter time to process
+		await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(receivedMessages).toHaveLength(2);
-    expect(receivedMessages.every((m) => m.type === 'user.created')).toBe(true);
+		expect(receivedMessages).toHaveLength(2);
+		expect(receivedMessages.every((m) => m.type === 'user.created')).toBe(true);
 
-    await connection.close();
-  });
+		await connection.close();
+	});
 
-  it('should handle multiple subscribers on same connection', async () => {
-    const connection = new BasicConnection();
-    await connection.connect();
+	it('should handle multiple subscribers on same connection', async () => {
+		const connection = new BasicConnection();
+		await connection.connect();
 
-    const publisher = new BasicPublisher<TestMessage>(connection);
-    const subscriber1 = new BasicSubscriber<TestMessage>(connection);
-    const subscriber2 = new BasicSubscriber<TestMessage>(connection);
+		const publisher = new BasicPublisher<TestMessage>(connection);
+		const subscriber1 = new BasicSubscriber<TestMessage>(connection);
+		const subscriber2 = new BasicSubscriber<TestMessage>(connection);
 
-    const messages1: TestMessage[] = [];
-    const messages2: TestMessage[] = [];
+		const messages1: TestMessage[] = [];
+		const messages2: TestMessage[] = [];
 
-    await subscriber1.subscribe(['user.created'], async (message) => {
-      messages1.push(message);
-    });
+		await subscriber1.subscribe(['user.created'], async (message) => {
+			messages1.push(message);
+		});
 
-    await subscriber2.subscribe(['user.created'], async (message) => {
-      messages2.push(message);
-    });
+		await subscriber2.subscribe(['user.created'], async (message) => {
+			messages2.push(message);
+		});
 
-    await publisher.publish([
-      { type: 'user.created', payload: { userId: '123' } },
-    ]);
+		await publisher.publish([
+			{ type: 'user.created', payload: { userId: '123' } },
+		]);
 
-    // Give event emitter time to process
-    await new Promise((resolve) => setTimeout(resolve, 10));
+		// Give event emitter time to process
+		await new Promise((resolve) => setTimeout(resolve, 10));
 
-    // Both subscribers should receive the message
-    expect(messages1).toHaveLength(1);
-    expect(messages2).toHaveLength(1);
+		// Both subscribers should receive the message
+		expect(messages1).toHaveLength(1);
+		expect(messages2).toHaveLength(1);
 
-    await connection.close();
-  });
+		await connection.close();
+	});
 
-  it('should handle async listener errors gracefully', async () => {
-    const connection = new BasicConnection();
-    await connection.connect();
+	it('should handle async listener errors gracefully', async () => {
+		const connection = new BasicConnection();
+		await connection.connect();
 
-    const publisher = new BasicPublisher<TestMessage>(connection);
-    const subscriber = new BasicSubscriber<TestMessage>(connection);
+		const publisher = new BasicPublisher<TestMessage>(connection);
+		const subscriber = new BasicSubscriber<TestMessage>(connection);
 
-    const receivedMessages: TestMessage[] = [];
+		const receivedMessages: TestMessage[] = [];
 
-    await subscriber.subscribe(['user.created'], async (message) => {
-      if (message.payload.userId === '2') {
-        throw new Error('Test error');
-      }
-      receivedMessages.push(message);
-    });
+		await subscriber.subscribe(['user.created'], async (message) => {
+			if (message.payload.userId === '2') {
+				throw new Error('Test error');
+			}
+			receivedMessages.push(message);
+		});
 
-    await publisher.publish([
-      { type: 'user.created', payload: { userId: '1' } },
-      { type: 'user.created', payload: { userId: '2' } },
-      { type: 'user.created', payload: { userId: '3' } },
-    ]);
+		await publisher.publish([
+			{ type: 'user.created', payload: { userId: '1' } },
+			{ type: 'user.created', payload: { userId: '2' } },
+			{ type: 'user.created', payload: { userId: '3' } },
+		]);
 
-    // Give event emitter time to process
-    await new Promise((resolve) => setTimeout(resolve, 10));
+		// Give event emitter time to process
+		await new Promise((resolve) => setTimeout(resolve, 10));
 
-    // Should receive messages 1 and 3 (2 throws error)
-    expect(receivedMessages).toHaveLength(2);
-    expect(receivedMessages[0].payload.userId).toBe('1');
-    expect(receivedMessages[1].payload.userId).toBe('3');
+		// Should receive messages 1 and 3 (2 throws error)
+		expect(receivedMessages).toHaveLength(2);
+		expect(receivedMessages[0].payload.userId).toBe('1');
+		expect(receivedMessages[1].payload.userId).toBe('3');
 
-    await connection.close();
-  });
+		await connection.close();
+	});
 });

package/src/index.ts

@@ -1,22 +1,22 @@
 // Generic types and interfaces
-export type {
-  EventConnection,
-  EventPublisher,
-  EventSubscriber,
-  ExtractPublisherMessage,
-  MappedEvent,
-  PublishableMessage,
-} from './types';
-export { EventPublisherType } from './types';
 
-// Generic factories
-export { Publisher } from './Publisher';
+export { EventConnectionFactory } from './EventConnection';
 export type { EventPublisherConnectionString } from './Publisher';
 
-export { Subscriber } from './Subscriber';
+// Generic factories
+export { Publisher } from './Publisher';
 export type { EventSubscriberConnectionString } from './Subscriber';
 
-export { EventConnectionFactory } from './EventConnection';
+export { Subscriber } from './Subscriber';
+export type {
+	EventConnection,
+	EventPublisher,
+	EventSubscriber,
+	ExtractPublisherMessage,
+	MappedEvent,
+	PublishableMessage,
+} from './types';
+export { EventPublisherType } from './types';
 
 // Specific integrations should be imported via subpaths:
 // - @geekmidas/events/basic