@geekmidas/events 0.1.0 → 0.2.0

package/src/sqs/SQSPublisher.ts

@@ -1,105 +1,105 @@
 import {
-  SendMessageBatchCommand,
-  type SendMessageBatchCommandInput,
-  type SendMessageBatchRequestEntry,
+	SendMessageBatchCommand,
+	type SendMessageBatchCommandInput,
+	type SendMessageBatchRequestEntry,
 } from '@aws-sdk/client-sqs';
 import chunk from 'lodash.chunk';
 import type { EventPublisher, PublishableMessage } from '../types';
 import type { SQSConnection } from './SQSConnection';
 
 export interface SQSPublisherOptions {
-  maxBatchSize?: number; // Default: 10 (SQS limit)
+	maxBatchSize?: number; // Default: 10 (SQS limit)
 }
 
 export class SQSPublisher<TMessage extends PublishableMessage<string, any>>
-  implements EventPublisher<TMessage>
+	implements EventPublisher<TMessage>
 {
-  readonly options: Required<SQSPublisherOptions>;
-
-  constructor(
-    readonly connection: SQSConnection,
-    options: SQSPublisherOptions = {},
-  ) {
-    this.options = {
-      maxBatchSize: options.maxBatchSize ?? 10, // SQS limit
-    };
-  }
-
-  /**
-   * Create an SQSPublisher from a connection string
-   * Format: sqs://?queueUrl=https://sqs.region.amazonaws.com/accountId/queueName&region=us-east-1&endpoint=http://localhost:4566&maxBatchSize=10
-   */
-  static async fromConnectionString<
-    TMessage extends PublishableMessage<string, any>,
-  >(connectionString: string): Promise<SQSPublisher<TMessage>> {
-    const url = new URL(connectionString);
-    const params = url.searchParams;
-
-    const { SQSConnection } = await import('./SQSConnection');
-    const connection =
-      await SQSConnection.fromConnectionString(connectionString);
-
-    const options: SQSPublisherOptions = {
-      maxBatchSize: params.get('maxBatchSize')
-        ? Number.parseInt(params.get('maxBatchSize')!, 10)
-        : undefined,
-    };
-
-    return new SQSPublisher<TMessage>(connection, options);
-  }
-
-  async publish(messages: TMessage[]): Promise<void> {
-    if (messages.length === 0) return;
-
-    if (!this.connection.isConnected()) {
-      await this.connection.connect();
-    }
-
-    // Split messages into batches (SQS limit is 10 messages per batch)
-    const batches = chunk(messages, this.options.maxBatchSize);
-
-    // Send all batches
-    await Promise.all(batches.map((batch) => this.sendBatch(batch)));
-  }
-
-  private async sendBatch(messages: TMessage[]): Promise<void> {
-    const entries: SendMessageBatchRequestEntry[] = messages.map(
-      (message, index) => ({
-        Id: `${index}`,
-        MessageBody: JSON.stringify({
-          type: message.type,
-          payload: message.payload,
-        }),
-        MessageAttributes: {
-          type: {
-            DataType: 'String',
-            StringValue: message.type,
-          },
-        },
-      }),
-    );
-
-    const input: SendMessageBatchCommandInput = {
-      QueueUrl: this.connection.queueUrl,
-      Entries: entries,
-    };
-
-    const command = new SendMessageBatchCommand(input);
-    const response = await this.connection.sqsClient.send(command);
-
-    // Check for failures
-    if (response.Failed && response.Failed.length > 0) {
-      const errors = response.Failed.map(
-        (f) => `${f.Id}: ${f.Code} - ${f.Message}`,
-      ).join(', ');
-      throw new Error(
-        `Failed to send ${response.Failed.length} messages: ${errors}`,
-      );
-    }
-  }
-
-  async close(): Promise<void> {
-    // Publisher doesn't own the connection
-    // Connection should be closed by whoever created it
-  }
+	readonly options: Required<SQSPublisherOptions>;
+
+	constructor(
+		readonly connection: SQSConnection,
+		options: SQSPublisherOptions = {},
+	) {
+		this.options = {
+			maxBatchSize: options.maxBatchSize ?? 10, // SQS limit
+		};
+	}
+
+	/**
+	 * Create an SQSPublisher from a connection string
+	 * Format: sqs://?queueUrl=https://sqs.region.amazonaws.com/accountId/queueName&region=us-east-1&endpoint=http://localhost:4566&maxBatchSize=10
+	 */
+	static async fromConnectionString<
+		TMessage extends PublishableMessage<string, any>,
+	>(connectionString: string): Promise<SQSPublisher<TMessage>> {
+		const url = new URL(connectionString);
+		const params = url.searchParams;
+
+		const { SQSConnection } = await import('./SQSConnection');
+		const connection =
+			await SQSConnection.fromConnectionString(connectionString);
+
+		const options: SQSPublisherOptions = {
+			maxBatchSize: params.get('maxBatchSize')
+				? Number.parseInt(params.get('maxBatchSize')!, 10)
+				: undefined,
+		};
+
+		return new SQSPublisher<TMessage>(connection, options);
+	}
+
+	async publish(messages: TMessage[]): Promise<void> {
+		if (messages.length === 0) return;
+
+		if (!this.connection.isConnected()) {
+			await this.connection.connect();
+		}
+
+		// Split messages into batches (SQS limit is 10 messages per batch)
+		const batches = chunk(messages, this.options.maxBatchSize);
+
+		// Send all batches
+		await Promise.all(batches.map((batch) => this.sendBatch(batch)));
+	}
+
+	private async sendBatch(messages: TMessage[]): Promise<void> {
+		const entries: SendMessageBatchRequestEntry[] = messages.map(
+			(message, index) => ({
+				Id: `${index}`,
+				MessageBody: JSON.stringify({
+					type: message.type,
+					payload: message.payload,
+				}),
+				MessageAttributes: {
+					type: {
+						DataType: 'String',
+						StringValue: message.type,
+					},
+				},
+			}),
+		);
+
+		const input: SendMessageBatchCommandInput = {
+			QueueUrl: this.connection.queueUrl,
+			Entries: entries,
+		};
+
+		const command = new SendMessageBatchCommand(input);
+		const response = await this.connection.sqsClient.send(command);
+
+		// Check for failures
+		if (response.Failed && response.Failed.length > 0) {
+			const errors = response.Failed.map(
+				(f) => `${f.Id}: ${f.Code} - ${f.Message}`,
+			).join(', ');
+			throw new Error(
+				`Failed to send ${response.Failed.length} messages: ${errors}`,
+			);
+		}
+	}
+
+	async close(): Promise<void> {
+		// Publisher doesn't own the connection
+		// Connection should be closed by whoever created it
+	}
 }

package/src/sqs/SQSSubscriber.ts

@@ -1,15 +1,15 @@
 import {
-  DeleteMessageCommand,
-  type Message,
-  ReceiveMessageCommand,
+	DeleteMessageCommand,
+	type Message,
+	ReceiveMessageCommand,
 } from '@aws-sdk/client-sqs';
 import type { EventSubscriber, PublishableMessage } from '../types';
 import type { SQSConnection } from './SQSConnection';
 
 export interface SQSSubscriberOptions {
-  waitTimeSeconds?: number; // SQS long polling (default: 20)
-  maxMessages?: number; // Max messages per poll (default: 10)
-  expectedTopicArn?: string; // Optional: verify messages are from specific SNS topic
+	waitTimeSeconds?: number; // SQS long polling (default: 20)
+	maxMessages?: number; // Max messages per poll (default: 10)
+	expectedTopicArn?: string; // Optional: verify messages are from specific SNS topic
 }
 
 /**
@@ -26,164 +26,156 @@ export interface SQSSubscriberOptions {
  * - Processes the actual message payload
  */
 export class SQSSubscriber<TMessage extends PublishableMessage<string, any>>
-  implements EventSubscriber<TMessage>
+	implements EventSubscriber<TMessage>
 {
-  private polling = false;
-  private messageTypes: Set<TMessage['type']> = new Set();
-  private listener?: (payload: TMessage) => Promise<void>;
-  private options: Required<SQSSubscriberOptions>;
-
-  constructor(
-    private connection: SQSConnection,
-    options: SQSSubscriberOptions = {},
-  ) {
-    this.options = {
-      waitTimeSeconds: options.waitTimeSeconds ?? 20,
-      maxMessages: options.maxMessages ?? 10,
-      expectedTopicArn: options.expectedTopicArn ?? '',
-    };
-  }
-
-  async subscribe(
-    messages: TMessage['type'][],
-    listener: (payload: TMessage) => Promise<void>,
-  ): Promise<void> {
-    this.messageTypes = new Set(messages);
-    this.listener = listener;
-
-    if (!this.connection.isConnected()) {
-      await this.connection.connect();
-    }
-
-    this.polling = true;
-    this.poll();
-  }
-
-  stop(): void {
-    this.polling = false;
-  }
-
-  private async poll(): Promise<void> {
-    while (this.polling) {
-      try {
-        const command = new ReceiveMessageCommand({
-          QueueUrl: this.connection.queueUrl,
-          MaxNumberOfMessages: this.options.maxMessages,
-          WaitTimeSeconds: this.options.waitTimeSeconds,
-          MessageAttributeNames: ['All'],
-        });
-
-        const response = await this.connection.sqsClient.send(command);
-
-        if (response.Messages && response.Messages.length > 0) {
-          await this.processMessages(response.Messages);
-        }
-      } catch (error) {
-        console.error('Error receiving messages from SQS:', error);
-        await this.sleep(1000);
-      }
-    }
-  }
-
-  private async processMessages(messages: Message[]): Promise<void> {
-    for (const message of messages) {
-      try {
-        if (!message.Body) continue;
-
-        // Try to parse as SNS message first
-        const parsedMessage = this.parseMessage(message.Body);
-
-        if (!parsedMessage) {
-          // Not a valid message format
-          await this.deleteMessage(message.ReceiptHandle!);
-          continue;
-        }
-
-        const { payload, messageType, topicArn } = parsedMessage;
-
-        // If expectedTopicArn is set, verify the message is from that topic
-        if (this.options.expectedTopicArn && topicArn) {
-          if (topicArn !== this.options.expectedTopicArn) {
-            console.warn(
-              `Received message from unexpected topic: ${topicArn}, expected: ${this.options.expectedTopicArn}`,
-            );
-            await this.deleteMessage(message.ReceiptHandle!);
-            continue;
-          }
-        }
-
-        // Check if we're subscribed to this message type
-        if (
-          messageType &&
-          this.messageTypes.has(messageType as TMessage['type'])
-        ) {
-          // Call listener
-          if (this.listener) {
-            await this.listener(payload as TMessage);
-          }
-
-          // Delete message after successful processing
-          await this.deleteMessage(message.ReceiptHandle!);
-        } else {
-          // Delete messages we're not subscribed to
-          await this.deleteMessage(message.ReceiptHandle!);
-        }
-      } catch (error) {
-        console.error('Error processing message:', error);
-        // Message will become visible again
-      }
-    }
-  }
-
-  /**
-   * Parse message body - handles both direct SQS messages and SNS-wrapped messages
-   */
-  private parseMessage(body: string): {
-    payload: unknown;
-    messageType: string | undefined;
-    topicArn?: string;
-  } | null {
-    try {
-      const parsed = JSON.parse(body);
-
-      // Check if this is an SNS notification wrapper
-      if (parsed.Type === 'Notification' && parsed.Message) {
-        // This is an SNS message
-        const snsMessage = JSON.parse(parsed.Message);
-        const messageType =
-          parsed.MessageAttributes?.type?.Value || snsMessage.type;
-
-        return {
-          payload: snsMessage,
-          messageType,
-          topicArn: parsed.TopicArn,
-        };
-      }
-
-      // This is a direct SQS message
-      return {
-        payload: parsed,
-        messageType: parsed.type,
-      };
-    } catch (error) {
-      console.error('Failed to parse message:', error);
-      return null;
-    }
-  }
-
-  private async deleteMessage(receiptHandle: string): Promise<void> {
-    try {
-      const command = new DeleteMessageCommand({
-        QueueUrl: this.connection.queueUrl,
-        ReceiptHandle: receiptHandle,
-      });
-      await this.connection.sqsClient.send(command);
-    } catch (error) {
-      console.error('Error deleting message:', error);
-    }
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
+	private polling = false;
+	private messageTypes: Set<TMessage['type']> = new Set();
+	private listener?: (payload: TMessage) => Promise<void>;
+	private options: Required<SQSSubscriberOptions>;
+
+	constructor(
+		private connection: SQSConnection,
+		options: SQSSubscriberOptions = {},
+	) {
+		this.options = {
+			waitTimeSeconds: options.waitTimeSeconds ?? 20,
+			maxMessages: options.maxMessages ?? 10,
+			expectedTopicArn: options.expectedTopicArn ?? '',
+		};
+	}
+
+	async subscribe(
+		messages: TMessage['type'][],
+		listener: (payload: TMessage) => Promise<void>,
+	): Promise<void> {
+		this.messageTypes = new Set(messages);
+		this.listener = listener;
+
+		if (!this.connection.isConnected()) {
+			await this.connection.connect();
+		}
+
+		this.polling = true;
+		this.poll();
+	}
+
+	stop(): void {
+		this.polling = false;
+	}
+
+	private async poll(): Promise<void> {
+		while (this.polling) {
+			try {
+				const command = new ReceiveMessageCommand({
+					QueueUrl: this.connection.queueUrl,
+					MaxNumberOfMessages: this.options.maxMessages,
+					WaitTimeSeconds: this.options.waitTimeSeconds,
+					MessageAttributeNames: ['All'],
+				});
+
+				const response = await this.connection.sqsClient.send(command);
+
+				if (response.Messages && response.Messages.length > 0) {
+					await this.processMessages(response.Messages);
+				}
+			} catch (_error) {
+				await this.sleep(1000);
+			}
+		}
+	}
+
+	private async processMessages(messages: Message[]): Promise<void> {
+		for (const message of messages) {
+			try {
+				if (!message.Body) continue;
+
+				// Try to parse as SNS message first
+				const parsedMessage = this.parseMessage(message.Body);
+
+				if (!parsedMessage) {
+					// Not a valid message format
+					await this.deleteMessage(message.ReceiptHandle!);
+					continue;
+				}
+
+				const { payload, messageType, topicArn } = parsedMessage;
+
+				// If expectedTopicArn is set, verify the message is from that topic
+				if (this.options.expectedTopicArn && topicArn) {
+					if (topicArn !== this.options.expectedTopicArn) {
+						await this.deleteMessage(message.ReceiptHandle!);
+						continue;
+					}
+				}
+
+				// Check if we're subscribed to this message type
+				if (
+					messageType &&
+					this.messageTypes.has(messageType as TMessage['type'])
+				) {
+					// Call listener
+					if (this.listener) {
+						await this.listener(payload as TMessage);
+					}
+
+					// Delete message after successful processing
+					await this.deleteMessage(message.ReceiptHandle!);
+				} else {
+					// Delete messages we're not subscribed to
+					await this.deleteMessage(message.ReceiptHandle!);
+				}
+			} catch (_error) {
+				// Message will become visible again
+			}
+		}
+	}
+
+	/**
+	 * Parse message body - handles both direct SQS messages and SNS-wrapped messages
+	 */
+	private parseMessage(body: string): {
+		payload: unknown;
+		messageType: string | undefined;
+		topicArn?: string;
+	} | null {
+		try {
+			const parsed = JSON.parse(body);
+
+			// Check if this is an SNS notification wrapper
+			if (parsed.Type === 'Notification' && parsed.Message) {
+				// This is an SNS message
+				const snsMessage = JSON.parse(parsed.Message);
+				const messageType =
+					parsed.MessageAttributes?.type?.Value || snsMessage.type;
+
+				return {
+					payload: snsMessage,
+					messageType,
+					topicArn: parsed.TopicArn,
+				};
+			}
+
+			// This is a direct SQS message
+			return {
+				payload: parsed,
+				messageType: parsed.type,
+			};
+		} catch (_error) {
+			return null;
+		}
+	}
+
+	private async deleteMessage(receiptHandle: string): Promise<void> {
+		try {
+			const command = new DeleteMessageCommand({
+				QueueUrl: this.connection.queueUrl,
+				ReceiptHandle: receiptHandle,
+			});
+			await this.connection.sqsClient.send(command);
+		} catch (_error) {}
+	}
+
+	private sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
 }