@geekmidas/events 9.0.2 → 10.0.0-alpha.0

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);
-					}
-				},
-			);
-		}
-	}
-}

package/src/pgboss/__tests__/pgboss.spec.ts

@@ -1,196 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import type { PublishableMessage } from '../../types';
-import { PgBossConnection } from '../PgBossConnection';
-import { PgBossPublisher } from '../PgBossPublisher';
-import { PgBossSubscriber } from '../PgBossSubscriber';
-import { dropSchemas } from './setup';
-
-type TestMessage =
-	| PublishableMessage<'user.created', { userId: string }>
-	| PublishableMessage<'user.updated', { userId: string; name: string }>;
-
-const POSTGRES_URL = 'postgres://geekmidas:geekmidas@localhost:5432/geekmidas';
-const PGBOSS_CONNECTION_STRING =
-	'pgboss://geekmidas:geekmidas@localhost:5432/geekmidas?schema=pgboss_test';
-
-const TEST_SCHEMAS = [
-	'pgboss_conn_test',
-	'pgboss_conn_test2',
-	'pgboss_test',
-	'pgboss_pub_test',
-	'pgboss_sub_test',
-];
-
-beforeAll(async () => {
-	await dropSchemas(POSTGRES_URL, TEST_SCHEMAS);
-});
-
-const uniqueQueue = () =>
-	`test-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-
-describe('PgBossConnection', () => {
-	it('should connect and report connected status', async () => {
-		const connection = new PgBossConnection({
-			connectionString: POSTGRES_URL,
-			schema: 'pgboss_conn_test',
-		});
-
-		expect(connection.isConnected()).toBe(false);
-		expect(connection.instance).toBeUndefined();
-
-		await connection.connect();
-
-		expect(connection.isConnected()).toBe(true);
-		expect(connection.instance).toBeDefined();
-
-		await connection.close();
-
-		expect(connection.isConnected()).toBe(false);
-	});
-
-	it('should not reconnect if already connected', async () => {
-		const connection = new PgBossConnection({
-			connectionString: POSTGRES_URL,
-			schema: 'pgboss_conn_test2',
-		});
-
-		await connection.connect();
-		const firstInstance = connection.instance;
-
-		await connection.connect();
-		expect(connection.instance).toBe(firstInstance);
-
-		await connection.close();
-	});
-
-	it('should parse connection string correctly', async () => {
-		const connection = await PgBossConnection.fromConnectionString(
-			PGBOSS_CONNECTION_STRING,
-		);
-
-		expect(connection.isConnected()).toBe(true);
-		expect(connection.instance).toBeDefined();
-
-		await connection.close();
-	});
-});
-
-describe('PgBossPublisher', () => {
-	let connection: PgBossConnection;
-
-	beforeAll(async () => {
-		connection = new PgBossConnection({
-			connectionString: POSTGRES_URL,
-			schema: 'pgboss_pub_test',
-		});
-		await connection.connect();
-	});
-
-	afterAll(async () => {
-		await connection.close();
-	});
-
-	it('should publish messages without errors', async () => {
-		const publisher = new PgBossPublisher<TestMessage>(connection);
-
-		await publisher.publish([
-			{ type: uniqueQueue() as any, payload: { userId: '1' } },
-		]);
-	});
-
-	it('should publish multiple messages with different types', async () => {
-		const publisher = new PgBossPublisher<TestMessage>(connection);
-		const queue1 = uniqueQueue() as any;
-		const queue2 = uniqueQueue() as any;
-
-		await publisher.publish([
-			{ type: queue1, payload: { userId: '1' } },
-			{ type: queue1, payload: { userId: '2' } },
-			{ type: queue2, payload: { userId: '3', name: 'Alice' } },
-		]);
-	});
-
-	it('should create publisher from connection string', async () => {
-		const publisher = await PgBossPublisher.fromConnectionString<TestMessage>(
-			PGBOSS_CONNECTION_STRING,
-		);
-
-		expect(publisher).toBeInstanceOf(PgBossPublisher);
-	});
-});
-
-describe('PgBossSubscriber', () => {
-	let connection: PgBossConnection;
-
-	beforeAll(async () => {
-		connection = new PgBossConnection({
-			connectionString: POSTGRES_URL,
-			schema: 'pgboss_sub_test',
-		});
-		await connection.connect();
-	});
-
-	afterAll(async () => {
-		await connection.close();
-	});
-
-	it('should receive published messages', async () => {
-		const queueName = uniqueQueue() as any;
-		const publisher = new PgBossPublisher<TestMessage>(connection);
-		const subscriber = new PgBossSubscriber<TestMessage>(connection, {
-			pollingIntervalSeconds: 1,
-		});
-
-		const received: TestMessage[] = [];
-
-		await subscriber.subscribe([queueName], async (message) => {
-			received.push(message);
-		});
-
-		await publisher.publish([{ type: queueName, payload: { userId: '42' } }]);
-
-		// Wait for pg-boss to poll and deliver
-		await new Promise((resolve) => setTimeout(resolve, 3000));
-
-		expect(received.length).toBe(1);
-		expect(received[0]).toEqual({
-			type: queueName,
-			payload: { userId: '42' },
-		});
-	});
-
-	it('should subscribe to multiple message types', async () => {
-		const queue1 = uniqueQueue() as any;
-		const queue2 = uniqueQueue() as any;
-		const publisher = new PgBossPublisher<TestMessage>(connection);
-		const subscriber = new PgBossSubscriber<TestMessage>(connection, {
-			pollingIntervalSeconds: 1,
-		});
-
-		const received: TestMessage[] = [];
-
-		await subscriber.subscribe([queue1, queue2], async (message) => {
-			received.push(message);
-		});
-
-		await publisher.publish([
-			{ type: queue1, payload: { userId: '1' } },
-			{ type: queue2, payload: { userId: '2', name: 'Bob' } },
-		]);
-
-		await new Promise((resolve) => setTimeout(resolve, 3000));
-
-		expect(received.length).toBe(2);
-		expect(received.map((m) => m.payload)).toEqual(
-			expect.arrayContaining([{ userId: '1' }, { userId: '2', name: 'Bob' }]),
-		);
-	});
-
-	it('should create subscriber from connection string with options', async () => {
-		const subscriber = await PgBossSubscriber.fromConnectionString<TestMessage>(
-			`${PGBOSS_CONNECTION_STRING}&batchSize=10`,
-		);
-
-		expect(subscriber).toBeInstanceOf(PgBossSubscriber);
-	});
-});

package/src/pgboss/__tests__/setup.ts

@@ -1,21 +0,0 @@
-import { Client } from 'pg';
-
-/**
- * Drop the named schemas if they exist. Run before pg-boss tests so that
- * pg-boss's contractor performs a fresh `create` rather than attempting to
- * migrate from a stale layout left behind by an older pg-boss version.
- */
-export async function dropSchemas(
-	connectionString: string,
-	schemas: string[],
-): Promise<void> {
-	const client = new Client({ connectionString });
-	await client.connect();
-	try {
-		for (const schema of schemas) {
-			await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
-		}
-	} finally {
-		await client.end();
-	}
-}

package/src/pgboss/index.ts

@@ -1,5 +0,0 @@
-export type { PgBossConnectionConfig } from './PgBossConnection';
-export { PgBossConnection } from './PgBossConnection';
-export { PgBossPublisher } from './PgBossPublisher';
-export type { PgBossSubscriberOptions } from './PgBossSubscriber';
-export { PgBossSubscriber } from './PgBossSubscriber';

package/src/rabbitmq/RabbitMQConnection.ts

@@ -1,148 +0,0 @@
-import amqplib from 'amqplib';
-import type { EventConnection } from '../types';
-import { EventPublisherType } from '../types';
-
-export interface RabbitMQConnectionConfig {
-	url: string;
-	exchange?: string;
-	exchangeType?: 'topic' | 'direct' | 'fanout' | 'headers';
-	exchangeOptions?: amqplib.Options.AssertExchange;
-	timeout?: number; // Connection timeout in milliseconds (default: 5000)
-}
-
-export class RabbitMQConnection implements EventConnection {
-	readonly type = EventPublisherType.RabbitMQ;
-	private connection?: amqplib.ChannelModel;
-	private channel?: amqplib.Channel;
-	private connecting?: Promise<void>;
-	private config: Required<
-		Pick<RabbitMQConnectionConfig, 'exchange' | 'exchangeType' | 'timeout'>
-	> &
-		RabbitMQConnectionConfig;
-
-	constructor(config: RabbitMQConnectionConfig) {
-		this.config = {
-			...config,
-			exchange: config.exchange || 'geekmidas.events',
-			exchangeType: config.exchangeType || 'topic',
-			timeout: config.timeout ?? 5000,
-			exchangeOptions: {
-				durable: true,
-				...config.exchangeOptions,
-			},
-		};
-	}
-
-	/**
-	 * Create a RabbitMQConnection from a connection string
-	 * Format: rabbitmq://user:pass@host:port/vhost?exchange=name&type=topic&timeout=5000
-	 */
-	static async fromConnectionString(
-		connectionString: string,
-	): Promise<RabbitMQConnection> {
-		const url = new URL(connectionString);
-		const params = url.searchParams;
-
-		// Extract connection URL without query params
-		const baseUrl = `amqp://${url.username ? `${url.username}:${url.password}@` : ''}${url.host}${url.pathname}`;
-
-		const timeoutParam = params.get('timeout');
-		const config: RabbitMQConnectionConfig = {
-			url: baseUrl,
-			exchange: params.get('exchange') || 'geekmidas.events',
-			exchangeType: (params.get('type') as any) || 'topic',
-			timeout: timeoutParam ? Number.parseInt(timeoutParam, 10) : undefined,
-		};
-
-		const connection = new RabbitMQConnection(config);
-		await connection.connect();
-		return connection;
-	}
-
-	async connect(): Promise<void> {
-		if (this.channel) return;
-
-		// Prevent multiple simultaneous connection attempts
-		if (this.connecting) {
-			await this.connecting;
-			return;
-		}
-
-		this.connecting = (async () => {
-			try {
-				const connection = await amqplib.connect(this.config.url, {
-					timeout: this.config.timeout,
-				});
-				const channel = await connection.createChannel();
-
-				// Assert the exchange exists
-				await channel.assertExchange(
-					this.config.exchange!,
-					this.config.exchangeType!,
-					this.config.exchangeOptions,
-				);
-
-				// Handle connection errors
-				connection.on('error', (_err: Error) => {
-					this.cleanup();
-				});
-
-				connection.on('close', () => {
-					this.cleanup();
-				});
-
-				// Only set after successful setup
-				this.connection = connection;
-				this.channel = channel;
-			} catch (error) {
-				this.cleanup();
-				throw error;
-			}
-		})();
-
-		await this.connecting;
-		this.connecting = undefined;
-	}
-
-	async close(): Promise<void> {
-		try {
-			await this.channel?.close();
-			await this.connection?.close();
-		} catch (_error) {
-			// Ignore errors during close
-		} finally {
-			this.cleanup();
-		}
-	}
-
-	isConnected(): boolean {
-		return !!this.channel;
-	}
-
-	private cleanup(): void {
-		this.channel = undefined;
-		this.connection = undefined;
-		this.connecting = undefined;
-	}
-
-	/**
-	 * Get the underlying channel for publishing/subscribing
-	 */
-	get amqpChannel(): amqplib.Channel | undefined {
-		return this.channel;
-	}
-
-	/**
-	 * Get the exchange name for this connection
-	 */
-	get exchangeName(): string {
-		return this.config.exchange;
-	}
-
-	/**
-	 * Get the exchange type for this connection
-	 */
-	get exchangeType(): string {
-		return this.config.exchangeType;
-	}
-}

package/src/rabbitmq/RabbitMQPublisher.ts

@@ -1,67 +0,0 @@
-import type amqplib from 'amqplib';
-import type { EventPublisher, PublishableMessage } from '../types';
-import type { RabbitMQConnection } from './RabbitMQConnection';
-
-export interface RabbitMQPublisherOptions {
-	publishOptions?: amqplib.Options.Publish;
-}
-
-export class RabbitMQPublisher<TMessage extends PublishableMessage<string, any>>
-	implements EventPublisher<TMessage>
-{
-	constructor(
-		private connection: RabbitMQConnection,
-		private options: RabbitMQPublisherOptions = {},
-	) {}
-
-	/**
-	 * Create a RabbitMQPublisher from a connection string
-	 * Format: rabbitmq://user:pass@host:port/vhost?exchange=name&type=topic&timeout=5000
-	 */
-	static async fromConnectionString<
-		TMessage extends PublishableMessage<string, any>,
-	>(connectionString: string): Promise<RabbitMQPublisher<TMessage>> {
-		const { RabbitMQConnection } = await import('./RabbitMQConnection');
-		const connection =
-			await RabbitMQConnection.fromConnectionString(connectionString);
-		return new RabbitMQPublisher<TMessage>(connection);
-	}
-
-	async publish(messages: TMessage[]): Promise<void> {
-		if (!this.connection.isConnected()) {
-			await this.connection.connect();
-		}
-
-		const channel = this.connection.amqpChannel;
-		if (!channel) {
-			throw new Error('Channel not initialized');
-		}
-
-		const exchange = this.connection.exchangeName;
-
-		for (const message of messages) {
-			const content = Buffer.from(JSON.stringify(message.payload));
-
-			// Use message type as routing key for topic exchanges
-			const routingKey = message.type;
-
-			const published = channel.publish(exchange, routingKey, content, {
-				contentType: 'application/json',
-				timestamp: Date.now(),
-				type: message.type,
-				persistent: true,
-				...this.options.publishOptions,
-			});
-
-			// Handle backpressure
-			if (!published) {
-				await new Promise((resolve) => channel.once('drain', resolve));
-			}
-		}
-	}
-
-	async close(): Promise<void> {
-		// Publisher doesn't own the connection
-		// Connection should be closed by whoever created it
-	}
-}

package/src/rabbitmq/RabbitMQSubscriber.ts

@@ -1,111 +0,0 @@
-import type amqplib from 'amqplib';
-import type { EventSubscriber, PublishableMessage } from '../types';
-import type { RabbitMQConnection } from './RabbitMQConnection';
-
-export interface RabbitMQSubscriberOptions {
-	queueName?: string; // If not provided, a unique queue will be generated
-	queueOptions?: amqplib.Options.AssertQueue;
-	consumeOptions?: amqplib.Options.Consume;
-	prefetch?: number; // Number of messages to prefetch (default: 1)
-}
-
-export class RabbitMQSubscriber<
-	TMessage extends PublishableMessage<string, any>,
-> implements EventSubscriber<TMessage>
-{
-	constructor(
-		private connection: RabbitMQConnection,
-		private options: RabbitMQSubscriberOptions = {},
-	) {}
-
-	/**
-	 * Create a RabbitMQSubscriber from a connection string
-	 * Format: rabbitmq://user:pass@host:port/vhost?exchange=name&type=topic&queueName=myqueue&prefetch=10
-	 */
-	static async fromConnectionString<
-		TMessage extends PublishableMessage<string, any>,
-	>(connectionString: string): Promise<RabbitMQSubscriber<TMessage>> {
-		const url = new URL(connectionString);
-		const params = url.searchParams;
-
-		const { RabbitMQConnection } = await import('./RabbitMQConnection');
-		const connection =
-			await RabbitMQConnection.fromConnectionString(connectionString);
-
-		const options: RabbitMQSubscriberOptions = {
-			queueName: params.get('queueName') || undefined,
-			prefetch: params.get('prefetch')
-				? Number.parseInt(params.get('prefetch')!, 10)
-				: undefined,
-		};
-
-		return new RabbitMQSubscriber<TMessage>(connection, options);
-	}
-
-	async subscribe(
-		messages: TMessage['type'][],
-		listener: (payload: TMessage) => Promise<void>,
-	): Promise<void> {
-		if (!this.connection.isConnected()) {
-			await this.connection.connect();
-		}
-
-		const channel = this.connection.amqpChannel;
-		if (!channel) {
-			throw new Error('Channel not initialized');
-		}
-
-		const exchange = this.connection.exchangeName;
-
-		// Set prefetch if specified
-		if (this.options.prefetch) {
-			await channel.prefetch(this.options.prefetch);
-		}
-
-		// Assert queue
-		const queueName = this.options.queueName || '';
-		const queueOptions: amqplib.Options.AssertQueue = {
-			durable: true,
-			...this.options.queueOptions,
-		};
-
-		const { queue } = await channel.assertQueue(queueName, queueOptions);
-
-		// Bind queue to exchange for each message type
-		for (const messageType of messages) {
-			await channel.bindQueue(queue, exchange, messageType);
-		}
-
-		// Consume messages
-		await channel.consume(
-			queue,
-			async (msg) => {
-				if (!msg) return;
-
-				try {
-					// Parse message payload
-					const content = msg.content.toString();
-					const payload = JSON.parse(content);
-
-					// Get message type from properties
-					const messageType = msg.properties.type;
-
-					// Reconstruct full message
-					const fullMessage: TMessage = {
-						type: messageType,
-						payload,
-					} as TMessage;
-
-					// Call listener
-					await listener(fullMessage);
-
-					// Ack message
-					channel.ack(msg);
-				} catch (_error) {
-					channel.nack(msg, false, true);
-				}
-			},
-			this.options.consumeOptions,
-		);
-	}
-}