@geekmidas/events 1.1.6 → 10.0.0-alpha.0

package/src/__tests__/Subscriber.spec.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { BasicConnection, BasicSubscriber } from '../basic';
-import { Subscriber } from '../Subscriber';
-import { SNSConnection } from '../sns/SNSConnection';
-import { SNSSubscriber } from '../sns/SNSSubscriber';
-import { SQSConnection } from '../sqs/SQSConnection';
-import { SQSSubscriber } from '../sqs/SQSSubscriber';
-import type { PublishableMessage } from '../types';
-
-type TestMessage = PublishableMessage<'test.event', { data: string }>;
-
-describe('Subscriber', () => {
-	describe('fromConnectionString', () => {
-		it('should create Basic subscriber from basic:// connection string', async () => {
-			const connectionStr = 'basic://localhost';
-
-			const subscriber =
-				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
-
-			expect(subscriber).toBeInstanceOf(BasicSubscriber);
-		});
-
-		it('should create SQS subscriber without topicArn', async () => {
-			const connectionStr =
-				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566';
-
-			const subscriber =
-				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
-
-			expect(subscriber).toBeInstanceOf(SQSSubscriber);
-		});
-
-		it('should create SNS subscriber when topicArn is present in SQS connection string', async () => {
-			const connectionStr =
-				'sqs://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&queueName=test-queue&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
-
-			const subscriber =
-				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
-
-			expect(subscriber).toBeInstanceOf(SNSSubscriber);
-		});
-
-		it('should create SNS subscriber from sns:// connection string', async () => {
-			const connectionStr =
-				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
-
-			const subscriber =
-				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
-
-			expect(subscriber).toBeInstanceOf(SNSSubscriber);
-		});
-
-		it('should throw error for unsupported protocol', async () => {
-			const connectionStr = 'unsupported://localhost';
-
-			await expect(
-				Subscriber.fromConnectionString<TestMessage>(connectionStr),
-			).rejects.toThrow('Unsupported event subscriber type');
-		});
-	});
-
-	describe('fromConnection', () => {
-		it('should create Basic subscriber from Basic connection', async () => {
-			const connection = new BasicConnection();
-			await connection.connect();
-
-			const subscriber =
-				await Subscriber.fromConnection<TestMessage>(connection);
-
-			expect(subscriber).toBeInstanceOf(BasicSubscriber);
-
-			await connection.close();
-		});
-
-		it('should create SQS subscriber from SQS connection', async () => {
-			const connection = await SQSConnection.fromConnectionString(
-				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566',
-			);
-
-			const subscriber =
-				await Subscriber.fromConnection<TestMessage>(connection);
-
-			expect(subscriber).toBeInstanceOf(SQSSubscriber);
-		});
-
-		it('should create SNS subscriber from SNS connection', async () => {
-			const connection = await SNSConnection.fromConnectionString(
-				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test',
-			);
-
-			const subscriber =
-				await Subscriber.fromConnection<TestMessage>(connection);
-
-			expect(subscriber).toBeInstanceOf(SNSSubscriber);
-
-			await connection.close();
-		});
-
-		it('should throw error for unsupported connection type', async () => {
-			const fakeConnection = {
-				type: 'unsupported' as any,
-			};
-
-			await expect(
-				Subscriber.fromConnection<TestMessage>(fakeConnection as any),
-			).rejects.toThrow('Unsupported connection type');
-		});
-	});
-});

package/src/basic/BasicConnection.ts

@@ -1,47 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { EventConnection } from '../types';
-import { EventPublisherType } from '../types';
-
-export class BasicConnection implements EventConnection {
-	readonly type = EventPublisherType.Basic;
-	private emitter: EventEmitter;
-	private connected = false;
-
-	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;
-	}
-
-	async connect(): Promise<void> {
-		this.connected = true;
-	}
-
-	async close(): Promise<void> {
-		this.emitter.removeAllListeners();
-		this.connected = false;
-	}
-
-	isConnected(): boolean {
-		return this.connected;
-	}
-
-	/**
-	 * Get the underlying EventEmitter
-	 * Used by BasicPublisher and BasicSubscriber
-	 */
-	get eventEmitter(): EventEmitter {
-		return this.emitter;
-	}
-}

package/src/basic/BasicPublisher.ts

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

package/src/basic/BasicSubscriber.ts

@@ -1,21 +0,0 @@
-import type { EventSubscriber, PublishableMessage } from '../types';
-import type { BasicConnection } from './BasicConnection';
-
-export class BasicSubscriber<TMessage extends PublishableMessage<string, any>>
-	implements EventSubscriber<TMessage>
-{
-	constructor(private connection: BasicConnection) {}
-
-	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) => {});
-			});
-		}
-	}
-}

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

@@ -1,166 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { PublishableMessage } from '../../types';
-import { BasicConnection } from '../BasicConnection';
-import { BasicPublisher } from '../BasicPublisher';
-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();
-
-		const publisher = new BasicPublisher<TestMessage>(connection);
-		const subscriber = new BasicSubscriber<TestMessage>(connection);
-
-		const receivedMessages: TestMessage[] = [];
-
-		await subscriber.subscribe(['user.created'], async (message) => {
-			receivedMessages.push(message);
-		});
-
-		await publisher.publish([
-			{ type: 'user.created', payload: { userId: '123' } },
-		]);
-
-		// 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' },
-		});
-
-		await connection.close();
-	});
-
-	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 receivedMessages: TestMessage[] = [];
-
-		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' } },
-		]);
-
-		// 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');
-
-		await connection.close();
-	});
-
-	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 receivedMessages: TestMessage[] = [];
-
-		// 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' } },
-		]);
-
-		// 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);
-
-		await connection.close();
-	});
-
-	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 messages1: TestMessage[] = [];
-		const messages2: TestMessage[] = [];
-
-		await subscriber1.subscribe(['user.created'], async (message) => {
-			messages1.push(message);
-		});
-
-		await subscriber2.subscribe(['user.created'], async (message) => {
-			messages2.push(message);
-		});
-
-		await publisher.publish([
-			{ type: 'user.created', payload: { userId: '123' } },
-		]);
-
-		// 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);
-
-		await connection.close();
-	});
-
-	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 receivedMessages: TestMessage[] = [];
-
-		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' } },
-		]);
-
-		// 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');
-
-		await connection.close();
-	});
-});

package/src/basic/index.ts

@@ -1,3 +0,0 @@
-export { BasicConnection } from './BasicConnection';
-export { BasicPublisher } from './BasicPublisher';
-export { BasicSubscriber } from './BasicSubscriber';

package/src/index.ts

@@ -1,25 +0,0 @@
-// Generic types and interfaces
-
-export { EventConnectionFactory } from './EventConnection';
-export type { EventPublisherConnectionString } from './Publisher';
-
-// Generic factories
-export { Publisher } from './Publisher';
-export type { EventSubscriberConnectionString } from './Subscriber';
-
-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
-// - @geekmidas/events/rabbitmq
-// - @geekmidas/events/sqs
-// - @geekmidas/events/sns

package/src/pgboss/PgBossConnection.ts

@@ -1,91 +0,0 @@
-import { PgBoss } from 'pg-boss';
-import type { EventConnection } from '../types';
-import { EventPublisherType } from '../types';
-
-export interface PgBossConnectionConfig {
-	connectionString: string;
-	schema?: string;
-}
-
-export class PgBossConnection implements EventConnection {
-	readonly type = EventPublisherType.PgBoss;
-	private boss?: PgBoss;
-	private connecting?: Promise<void>;
-
-	constructor(private config: PgBossConnectionConfig) {}
-
-	/**
-	 * Create a PgBossConnection from a connection string.
-	 * Format: pgboss://user:pass@host:5432/database?schema=pgboss
-	 */
-	static async fromConnectionString(
-		connectionString: string,
-	): Promise<PgBossConnection> {
-		const url = new URL(connectionString);
-		const params = url.searchParams;
-
-		const postgresUrl = `postgres://${url.username ? `${url.username}:${url.password}@` : ''}${url.host}${url.pathname}`;
-
-		const config: PgBossConnectionConfig = {
-			connectionString: postgresUrl,
-			schema: params.get('schema') || undefined,
-		};
-
-		const connection = new PgBossConnection(config);
-		await connection.connect();
-		return connection;
-	}
-
-	async connect(): Promise<void> {
-		if (this.boss) return;
-
-		if (this.connecting) {
-			await this.connecting;
-			return;
-		}
-
-		this.connecting = (async () => {
-			try {
-				const boss = new PgBoss({
-					connectionString: this.config.connectionString,
-					...(this.config.schema && { schema: this.config.schema }),
-				});
-
-				await boss.start();
-				this.boss = boss;
-			} catch (error) {
-				this.cleanup();
-				throw error;
-			}
-		})();
-
-		await this.connecting;
-		this.connecting = undefined;
-	}
-
-	async close(): Promise<void> {
-		try {
-			await this.boss?.stop({ graceful: true });
-		} catch {
-			// Ignore errors during close
-		} finally {
-			this.cleanup();
-		}
-	}
-
-	isConnected(): boolean {
-		return !!this.boss;
-	}
-
-	private cleanup(): void {
-		this.boss = undefined;
-		this.connecting = undefined;
-	}
-
-	/**
-	 * Get the underlying pg-boss instance for publishing/subscribing
-	 */
-	get instance(): PgBoss | undefined {
-		return this.boss;
-	}
-}

package/src/pgboss/PgBossPublisher.ts

@@ -1,49 +0,0 @@
-import type { EventPublisher, PublishableMessage } from '../types';
-import type { PgBossConnection } from './PgBossConnection';
-
-export class PgBossPublisher<TMessage extends PublishableMessage<string, any>>
-	implements EventPublisher<TMessage>
-{
-	constructor(private connection: PgBossConnection) {}
-
-	/**
-	 * Create a PgBossPublisher from a connection string.
-	 * Format: pgboss://user:pass@host:5432/database?schema=pgboss
-	 */
-	static async fromConnectionString<
-		TMessage extends PublishableMessage<string, any>,
-	>(connectionString: string): Promise<PgBossPublisher<TMessage>> {
-		const { PgBossConnection } = await import('./PgBossConnection');
-		const connection =
-			await PgBossConnection.fromConnectionString(connectionString);
-		return new PgBossPublisher<TMessage>(connection);
-	}
-
-	async publish(messages: TMessage[]): Promise<void> {
-		if (!this.connection.isConnected()) {
-			await this.connection.connect();
-		}
-
-		const boss = this.connection.instance;
-		if (!boss) {
-			throw new Error('PgBoss instance not initialized');
-		}
-
-		// Group jobs by queue name (v11+ requires per-queue insert calls)
-		const groups = new Map<string, { data: TMessage['payload'] }[]>();
-		for (const m of messages) {
-			const list = groups.get(m.type) ?? [];
-			list.push({ data: m.payload });
-			groups.set(m.type, list);
-		}
-
-		for (const [name, jobs] of groups) {
-			await boss.createQueue(name);
-			await boss.insert(name, jobs);
-		}
-	}
-
-	async close(): Promise<void> {
-		// Publisher doesn't own the connection
-	}
-}

package/src/pgboss/PgBossSubscriber.ts

@@ -1,81 +0,0 @@
-import type { EventSubscriber, PublishableMessage } from '../types';
-import type { PgBossConnection } from './PgBossConnection';
-
-export interface PgBossSubscriberOptions {
-	batchSize?: number;
-	pollingIntervalSeconds?: number;
-}
-
-export class PgBossSubscriber<TMessage extends PublishableMessage<string, any>>
-	implements EventSubscriber<TMessage>
-{
-	constructor(
-		private connection: PgBossConnection,
-		private options: PgBossSubscriberOptions = {},
-	) {}
-
-	/**
-	 * Create a PgBossSubscriber from a connection string.
-	 * Format: pgboss://user:pass@host:5432/database?schema=pgboss&batchSize=5
-	 */
-	static async fromConnectionString<
-		TMessage extends PublishableMessage<string, any>,
-	>(connectionString: string): Promise<PgBossSubscriber<TMessage>> {
-		const url = new URL(connectionString);
-		const params = url.searchParams;
-
-		const { PgBossConnection } = await import('./PgBossConnection');
-		const connection =
-			await PgBossConnection.fromConnectionString(connectionString);
-
-		const options: PgBossSubscriberOptions = {
-			batchSize: params.get('batchSize')
-				? Number.parseInt(params.get('batchSize')!, 10)
-				: undefined,
-			pollingIntervalSeconds: params.get('pollingIntervalSeconds')
-				? Number.parseInt(params.get('pollingIntervalSeconds')!, 10)
-				: undefined,
-		};
-
-		return new PgBossSubscriber<TMessage>(connection, options);
-	}
-
-	async subscribe(
-		messages: TMessage['type'][],
-		listener: (payload: TMessage) => Promise<void>,
-	): Promise<void> {
-		if (!this.connection.isConnected()) {
-			await this.connection.connect();
-		}
-
-		const boss = this.connection.instance;
-		if (!boss) {
-			throw new Error('PgBoss instance not initialized');
-		}
-
-		for (const messageType of messages) {
-			await boss.createQueue(messageType);
-			await boss.work(
-				messageType,
-				{
-					...(this.options.batchSize && {
-						batchSize: this.options.batchSize,
-					}),
-					...(this.options.pollingIntervalSeconds && {
-						pollingIntervalSeconds: this.options.pollingIntervalSeconds,
-					}),
-				},
-				async (jobs) => {
-					for (const job of jobs) {
-						const fullMessage = {
-							type: job.name,
-							payload: job.data,
-						} as TMessage;
-
-						await listener(fullMessage);
-					}
-				},
-			);
-		}
-	}
-}