@geekmidas/events 0.0.1

package/src/sns/__tests__/SNS-SQS-Integration.spec.ts

@@ -0,0 +1,389 @@
+import {
+  CreateTopicCommand,
+  DeleteTopicCommand,
+  SNSClient,
+  SubscribeCommand,
+  UnsubscribeCommand,
+} from '@aws-sdk/client-sns';
+import {
+  CreateQueueCommand,
+  DeleteQueueCommand,
+  GetQueueAttributesCommand,
+  SQSClient,
+  SetQueueAttributesCommand,
+} from '@aws-sdk/client-sqs';
+import { describe, expect, it } from 'vitest';
+import { SQSConnection } from '../../sqs/SQSConnection';
+import { SQSSubscriber } from '../../sqs/SQSSubscriber';
+import type { PublishableMessage } from '../../types';
+import { SNSConnection } from '../SNSConnection';
+import { SNSPublisher } from '../SNSPublisher';
+
+type TestMessage = PublishableMessage<'user.created' | 'user.updated', any>;
+
+const LOCALSTACK_ENDPOINT = 'http://localhost:4566';
+const AWS_REGION = 'us-east-1';
+const AWS_CREDENTIALS = {
+  accessKeyId: 'test',
+  secretAccessKey: 'test',
+};
+
+// Helper to create a unique topic name
+const uniqueTopicName = () =>
+  `test-topic-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+// Helper to create a unique queue name
+const uniqueQueueName = () =>
+  `test-queue-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+// Helper to create an SNS topic and return its ARN
+async function createTopic(topicName: string): Promise<string> {
+  const client = new SNSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new CreateTopicCommand({
+    Name: topicName,
+  });
+
+  const response = await client.send(command);
+  client.destroy();
+
+  if (!response.TopicArn) {
+    throw new Error('Failed to create topic');
+  }
+
+  return response.TopicArn;
+}
+
+// Helper to delete an SNS topic
+async function deleteTopic(topicArn: string): Promise<void> {
+  const client = new SNSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new DeleteTopicCommand({
+    TopicArn: topicArn,
+  });
+
+  await client.send(command);
+  client.destroy();
+}
+
+// Helper to create an SQS queue and return its URL
+async function createQueue(queueName: string): Promise<string> {
+  const client = new SQSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new CreateQueueCommand({
+    QueueName: queueName,
+  });
+
+  const response = await client.send(command);
+  client.destroy();
+
+  if (!response.QueueUrl) {
+    throw new Error('Failed to create queue');
+  }
+
+  return response.QueueUrl;
+}
+
+// Helper to get queue ARN
+async function getQueueArn(queueUrl: string): Promise<string> {
+  const client = new SQSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new GetQueueAttributesCommand({
+    QueueUrl: queueUrl,
+    AttributeNames: ['QueueArn'],
+  });
+
+  const response = await client.send(command);
+  client.destroy();
+
+  const queueArn = response.Attributes?.QueueArn;
+  if (!queueArn) {
+    throw new Error('Failed to get queue ARN');
+  }
+
+  return queueArn;
+}
+
+// Helper to set queue policy to allow SNS to send messages
+async function setQueuePolicy(
+  queueUrl: string,
+  queueArn: string,
+  topicArn: string,
+): Promise<void> {
+  const client = new SQSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const policy = {
+    Version: '2012-10-17',
+    Statement: [
+      {
+        Effect: 'Allow',
+        Principal: '*',
+        Action: 'SQS:SendMessage',
+        Resource: queueArn,
+        Condition: {
+          ArnEquals: {
+            'aws:SourceArn': topicArn,
+          },
+        },
+      },
+    ],
+  };
+
+  const command = new SetQueueAttributesCommand({
+    QueueUrl: queueUrl,
+    Attributes: {
+      Policy: JSON.stringify(policy),
+    },
+  });
+
+  await client.send(command);
+  client.destroy();
+}
+
+// Helper to subscribe SQS queue to SNS topic
+async function subscribeQueueToTopic(
+  topicArn: string,
+  queueArn: string,
+): Promise<string> {
+  const client = new SNSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new SubscribeCommand({
+    TopicArn: topicArn,
+    Protocol: 'sqs',
+    Endpoint: queueArn,
+  });
+
+  const response = await client.send(command);
+  client.destroy();
+
+  if (!response.SubscriptionArn) {
+    throw new Error('Failed to subscribe queue to topic');
+  }
+
+  return response.SubscriptionArn;
+}
+
+// Helper to unsubscribe
+async function unsubscribe(subscriptionArn: string): Promise<void> {
+  const client = new SNSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new UnsubscribeCommand({
+    SubscriptionArn: subscriptionArn,
+  });
+
+  await client.send(command);
+  client.destroy();
+}
+
+// Helper to delete a queue
+async function deleteQueue(queueUrl: string): Promise<void> {
+  const client = new SQSClient({
+    region: AWS_REGION,
+    endpoint: LOCALSTACK_ENDPOINT,
+    credentials: AWS_CREDENTIALS,
+  });
+
+  const command = new DeleteQueueCommand({
+    QueueUrl: queueUrl,
+  });
+
+  await client.send(command);
+  client.destroy();
+}
+
+describe('SNS to SQS Integration Tests', () => {
+  it('should publish to SNS and receive via SQS subscription', async () => {
+    const topicName = uniqueTopicName();
+    const queueName = uniqueQueueName();
+
+    const topicArn = await createTopic(topicName);
+    const queueUrl = await createQueue(queueName);
+    const queueArn = await getQueueArn(queueUrl);
+
+    // Set queue policy to allow SNS
+    await setQueuePolicy(queueUrl, queueArn, topicArn);
+
+    // Subscribe queue to topic
+    const subscriptionArn = await subscribeQueueToTopic(topicArn, queueArn);
+
+    try {
+      // Wait a moment for subscription to be ready
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Create SNS publisher
+      const snsConnection = new SNSConnection({
+        topicArn,
+        endpoint: LOCALSTACK_ENDPOINT,
+        region: AWS_REGION,
+        credentials: AWS_CREDENTIALS,
+      });
+      await snsConnection.connect();
+
+      const snsPublisher = new SNSPublisher<TestMessage>(snsConnection);
+
+      // Create SQS subscriber
+      const sqsConnection = new SQSConnection({
+        queueUrl,
+        endpoint: LOCALSTACK_ENDPOINT,
+        region: AWS_REGION,
+        credentials: AWS_CREDENTIALS,
+      });
+      await sqsConnection.connect();
+
+      const sqsSubscriber = new SQSSubscriber<TestMessage>(sqsConnection, {
+        waitTimeSeconds: 1,
+      });
+
+      const receivedMessages: TestMessage[] = [];
+
+      await sqsSubscriber.subscribe(['user.created'], async (message) => {
+        receivedMessages.push(message);
+      });
+
+      // Publish via SNS
+      await snsPublisher.publish([
+        { type: 'user.created', payload: { userId: '123' } },
+      ]);
+
+      // Wait for message to be delivered (SNS to SQS is nearly instant)
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+
+      sqsSubscriber.stop();
+
+      expect(receivedMessages).toHaveLength(1);
+      expect(receivedMessages[0].type).toBe('user.created');
+      expect(receivedMessages[0].payload.userId).toBe('123');
+
+      await snsConnection.close();
+      await sqsConnection.close();
+    } finally {
+      await unsubscribe(subscriptionArn);
+      await deleteQueue(queueUrl);
+      await deleteTopic(topicArn);
+    }
+  }, 15000);
+
+  it('should fan out to multiple SQS queues', async () => {
+    const topicName = uniqueTopicName();
+    const queue1Name = uniqueQueueName();
+    const queue2Name = uniqueQueueName();
+
+    const topicArn = await createTopic(topicName);
+    const queue1Url = await createQueue(queue1Name);
+    const queue2Url = await createQueue(queue2Name);
+    const queue1Arn = await getQueueArn(queue1Url);
+    const queue2Arn = await getQueueArn(queue2Url);
+
+    await setQueuePolicy(queue1Url, queue1Arn, topicArn);
+    await setQueuePolicy(queue2Url, queue2Arn, topicArn);
+
+    const subscription1Arn = await subscribeQueueToTopic(topicArn, queue1Arn);
+    const subscription2Arn = await subscribeQueueToTopic(topicArn, queue2Arn);
+
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Create SNS publisher
+      const snsConnection = new SNSConnection({
+        topicArn,
+        endpoint: LOCALSTACK_ENDPOINT,
+        region: AWS_REGION,
+        credentials: AWS_CREDENTIALS,
+      });
+      await snsConnection.connect();
+
+      const snsPublisher = new SNSPublisher<TestMessage>(snsConnection);
+
+      // Create SQS subscribers for both queues
+      const sqsConnection1 = new SQSConnection({
+        queueUrl: queue1Url,
+        endpoint: LOCALSTACK_ENDPOINT,
+        region: AWS_REGION,
+        credentials: AWS_CREDENTIALS,
+      });
+      await sqsConnection1.connect();
+
+      const sqsConnection2 = new SQSConnection({
+        queueUrl: queue2Url,
+        endpoint: LOCALSTACK_ENDPOINT,
+        region: AWS_REGION,
+        credentials: AWS_CREDENTIALS,
+      });
+      await sqsConnection2.connect();
+
+      const sqsSubscriber1 = new SQSSubscriber<TestMessage>(sqsConnection1, {
+        waitTimeSeconds: 1,
+      });
+
+      const sqsSubscriber2 = new SQSSubscriber<TestMessage>(sqsConnection2, {
+        waitTimeSeconds: 1,
+      });
+
+      const queue1Messages: TestMessage[] = [];
+      const queue2Messages: TestMessage[] = [];
+
+      await sqsSubscriber1.subscribe(['user.created'], async (message) => {
+        queue1Messages.push(message);
+      });
+
+      await sqsSubscriber2.subscribe(['user.created'], async (message) => {
+        queue2Messages.push(message);
+      });
+
+      // Publish via SNS
+      await snsPublisher.publish([
+        { type: 'user.created', payload: { userId: '456' } },
+      ]);
+
+      // Wait for messages
+      await new Promise((resolve) => setTimeout(resolve, 3000));
+
+      sqsSubscriber1.stop();
+      sqsSubscriber2.stop();
+
+      // Both queues should receive the message
+      expect(queue1Messages).toHaveLength(1);
+      expect(queue2Messages).toHaveLength(1);
+      expect(queue1Messages[0].payload.userId).toBe('456');
+      expect(queue2Messages[0].payload.userId).toBe('456');
+
+      await snsConnection.close();
+      await sqsConnection1.close();
+      await sqsConnection2.close();
+    } finally {
+      await unsubscribe(subscription1Arn);
+      await unsubscribe(subscription2Arn);
+      await deleteQueue(queue1Url);
+      await deleteQueue(queue2Url);
+      await deleteTopic(topicArn);
+    }
+  }, 20000);
+});

package/src/sns/index.ts

@@ -0,0 +1,6 @@
+export { SNSConnection } from './SNSConnection';
+export type { SNSConnectionConfig } from './SNSConnection';
+export { SNSPublisher } from './SNSPublisher';
+export type { SNSPublisherOptions } from './SNSPublisher';
+export { SNSSubscriber } from './SNSSubscriber';
+export type { SNSSubscriberOptions } from './SNSSubscriber';

package/src/sqs/SQSConnection.ts

@@ -0,0 +1,97 @@
+import { SQSClient, type SQSClientConfig } from '@aws-sdk/client-sqs';
+import type { EventConnection } from '../types';
+import { EventPublisherType } from '../types';
+
+export interface SQSConnectionConfig {
+  queueUrl: string;
+  region?: string;
+  endpoint?: string; // Custom endpoint (e.g., for LocalStack)
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+  };
+}
+
+export class SQSConnection implements EventConnection {
+  readonly type = EventPublisherType.SQS;
+  private client: SQSClient;
+  private connected = false;
+
+  constructor(readonly config: SQSConnectionConfig) {
+    this.config = config;
+
+    const clientConfig: SQSClientConfig = {
+      region: config.region,
+      endpoint: config.endpoint,
+      credentials: config.credentials,
+    };
+
+    this.client = new SQSClient(clientConfig);
+  }
+
+  /**
+   * Create an SQSConnection from a connection string
+   * Format: sqs://?queueUrl=https://sqs.region.amazonaws.com/accountId/queueName&region=us-east-1&endpoint=http://localhost:4566
+   */
+  static async fromConnectionString(
+    connectionString: string,
+  ): Promise<SQSConnection> {
+    const url = new URL(connectionString);
+    const params = url.searchParams;
+
+    const queueUrl = params.get('queueUrl');
+    if (!queueUrl) {
+      throw new Error('queueUrl parameter is required in connection string');
+    }
+
+    const config: SQSConnectionConfig = {
+      queueUrl,
+      region: params.get('region') || undefined,
+      endpoint: params.get('endpoint') || undefined,
+    };
+
+    // Parse credentials if provided
+    const accessKeyId = params.get('accessKeyId');
+    const secretAccessKey = params.get('secretAccessKey');
+    if (accessKeyId && secretAccessKey) {
+      config.credentials = {
+        accessKeyId,
+        secretAccessKey,
+        sessionToken: params.get('sessionToken') || undefined,
+      };
+    }
+
+    const connection = new SQSConnection(config);
+    await connection.connect();
+    return connection;
+  }
+
+  async connect(): Promise<void> {
+    // SQS doesn't have a traditional connection, but we mark as connected
+    this.connected = true;
+  }
+
+  async close(): Promise<void> {
+    this.client.destroy();
+    this.connected = false;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * Get the underlying SQS client
+   */
+  get sqsClient(): SQSClient {
+    return this.client;
+  }
+
+  /**
+   * Get the queue URL for this connection
+   */
+  get queueUrl(): string {
+    return this.config.queueUrl;
+  }
+}

package/src/sqs/SQSPublisher.ts

@@ -0,0 +1,105 @@
+import {
+  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)
+}
+
+export class SQSPublisher<TMessage extends PublishableMessage<string, any>>
+  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
+  }
+}