@geekmidas/events 0.0.1

package/src/index.ts

@@ -0,0 +1,25 @@
+// 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 type { EventPublisherConnectionString } from './Publisher';
+
+export { Subscriber } from './Subscriber';
+export type { EventSubscriberConnectionString } from './Subscriber';
+
+export { EventConnectionFactory } from './EventConnection';
+
+// Specific integrations should be imported via subpaths:
+// - @geekmidas/events/basic
+// - @geekmidas/events/rabbitmq
+// - @geekmidas/events/sqs
+// - @geekmidas/events/sns

package/src/rabbitmq/RabbitMQConnection.ts

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,67 @@
+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

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