@geekmidas/events 0.1.0 → 1.0.0

package/src/rabbitmq/RabbitMQConnection.ts

@@ -3,146 +3,146 @@ 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)
+	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;
-  }
+	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

@@ -3,65 +3,65 @@ import type { EventPublisher, PublishableMessage } from '../types';
 import type { RabbitMQConnection } from './RabbitMQConnection';
 
 export interface RabbitMQPublisherOptions {
-  publishOptions?: amqplib.Options.Publish;
+	publishOptions?: amqplib.Options.Publish;
 }
 
 export class RabbitMQPublisher<TMessage extends PublishableMessage<string, any>>
-  implements EventPublisher<TMessage>
+	implements EventPublisher<TMessage>
 {
-  constructor(
-    private connection: RabbitMQConnection,
-    private options: RabbitMQPublisherOptions = {},
-  ) {}
+	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);
-  }
+	/**
+	 * 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();
-    }
+	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 channel = this.connection.amqpChannel;
+		if (!channel) {
+			throw new Error('Channel not initialized');
+		}
 
-    const exchange = this.connection.exchangeName;
+		const exchange = this.connection.exchangeName;
 
-    for (const message of messages) {
-      const content = Buffer.from(JSON.stringify(message.payload));
+		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;
+			// 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,
-      });
+			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));
-      }
-    }
-  }
+			// 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
-  }
+	async close(): Promise<void> {
+		// Publisher doesn't own the connection
+		// Connection should be closed by whoever created it
+	}
 }

package/src/rabbitmq/RabbitMQSubscriber.ts

@@ -3,111 +3,109 @@ 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)
+	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>,
+	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) {
-          // Log error and nack message (requeue)
-          console.error('Error processing message:', error);
-          channel.nack(msg, false, true);
-        }
-      },
-      this.options.consumeOptions,
-    );
-  }
+	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,
+		);
+	}
 }