@geekmidas/events 0.0.2 → 0.2.0

package/src/sns/SNSConnection.ts

@@ -3,96 +3,96 @@ import type { EventConnection } from '../types';
 import { EventPublisherType } from '../types';
 
 export interface SNSConnectionConfig {
-  topicArn: string;
-  region?: string;
-  endpoint?: string; // Custom endpoint (e.g., for LocalStack)
-  credentials?: {
-    accessKeyId: string;
-    secretAccessKey: string;
-    sessionToken?: string;
-  };
+	topicArn: string;
+	region?: string;
+	endpoint?: string; // Custom endpoint (e.g., for LocalStack)
+	credentials?: {
+		accessKeyId: string;
+		secretAccessKey: string;
+		sessionToken?: string;
+	};
 }
 
 export class SNSConnection implements EventConnection {
-  readonly type = EventPublisherType.SNS;
-  private client: SNSClient;
-  private connected = false;
-  private config: SNSConnectionConfig;
+	readonly type = EventPublisherType.SNS;
+	private client: SNSClient;
+	private connected = false;
+	private config: SNSConnectionConfig;
 
-  constructor(config: SNSConnectionConfig) {
-    this.config = config;
+	constructor(config: SNSConnectionConfig) {
+		this.config = config;
 
-    const clientConfig: SNSClientConfig = {
-      region: config.region,
-      endpoint: config.endpoint,
-      credentials: config.credentials,
-    };
+		const clientConfig: SNSClientConfig = {
+			region: config.region,
+			endpoint: config.endpoint,
+			credentials: config.credentials,
+		};
 
-    this.client = new SNSClient(clientConfig);
-  }
+		this.client = new SNSClient(clientConfig);
+	}
 
-  /**
-   * Create an SNSConnection from a connection string
-   * Format: sns://?topicArn=arn:aws:sns:region:account:topic&region=us-east-1&endpoint=http://localhost:4566
-   */
-  static async fromConnectionString(
-    connectionString: string,
-  ): Promise<SNSConnection> {
-    const url = new URL(connectionString);
-    const params = url.searchParams;
+	/**
+	 * Create an SNSConnection from a connection string
+	 * Format: sns://?topicArn=arn:aws:sns:region:account:topic&region=us-east-1&endpoint=http://localhost:4566
+	 */
+	static async fromConnectionString(
+		connectionString: string,
+	): Promise<SNSConnection> {
+		const url = new URL(connectionString);
+		const params = url.searchParams;
 
-    const topicArn = params.get('topicArn');
-    if (!topicArn) {
-      throw new Error('topicArn parameter is required in connection string');
-    }
+		const topicArn = params.get('topicArn');
+		if (!topicArn) {
+			throw new Error('topicArn parameter is required in connection string');
+		}
 
-    const config: SNSConnectionConfig = {
-      topicArn,
-      region: params.get('region') || undefined,
-      endpoint: params.get('endpoint') || undefined,
-    };
+		const config: SNSConnectionConfig = {
+			topicArn,
+			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,
-      };
-    }
+		// 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 SNSConnection(config);
-    await connection.connect();
-    return connection;
-  }
+		const connection = new SNSConnection(config);
+		await connection.connect();
+		return connection;
+	}
 
-  async connect(): Promise<void> {
-    // SNS doesn't have a traditional connection, but we mark as connected
-    this.connected = true;
-  }
+	async connect(): Promise<void> {
+		// SNS doesn't have a traditional connection, but we mark as connected
+		this.connected = true;
+	}
 
-  async close(): Promise<void> {
-    this.client.destroy();
-    this.connected = false;
-  }
+	async close(): Promise<void> {
+		this.client.destroy();
+		this.connected = false;
+	}
 
-  isConnected(): boolean {
-    return this.connected;
-  }
+	isConnected(): boolean {
+		return this.connected;
+	}
 
-  /**
-   * Get the underlying SNS client
-   */
-  get snsClient(): SNSClient {
-    return this.client;
-  }
+	/**
+	 * Get the underlying SNS client
+	 */
+	get snsClient(): SNSClient {
+		return this.client;
+	}
 
-  /**
-   * Get the topic ARN for this connection
-   */
-  get topicArn(): string {
-    return this.config.topicArn;
-  }
+	/**
+	 * Get the topic ARN for this connection
+	 */
+	get topicArn(): string {
+		return this.config.topicArn;
+	}
 }

package/src/sns/SNSPublisher.ts

@@ -2,63 +2,61 @@ import { PublishCommand } from '@aws-sdk/client-sns';
 import type { EventPublisher, PublishableMessage } from '../types';
 import type { SNSConnection } from './SNSConnection';
 
-export interface SNSPublisherOptions {
-  // Optional publisher-specific options
-}
+export type SNSPublisherOptions = {};
 
 export class SNSPublisher<TMessage extends PublishableMessage<string, any>>
-  implements EventPublisher<TMessage>
+	implements EventPublisher<TMessage>
 {
-  constructor(
-    private connection: SNSConnection,
-    private options: SNSPublisherOptions = {},
-  ) {}
-
-  /**
-   * Create an SNSPublisher from a connection string
-   * Format: sns://?topicArn=arn:aws:sns:region:account:topic&region=us-east-1&endpoint=http://localhost:4566
-   */
-  static async fromConnectionString<
-    TMessage extends PublishableMessage<string, any>,
-  >(connectionString: string): Promise<SNSPublisher<TMessage>> {
-    const { SNSConnection } = await import('./SNSConnection');
-    const connection =
-      await SNSConnection.fromConnectionString(connectionString);
-
-    return new SNSPublisher<TMessage>(connection);
-  }
-
-  async publish(messages: TMessage[]): Promise<void> {
-    if (messages.length === 0) return;
-
-    if (!this.connection.isConnected()) {
-      await this.connection.connect();
-    }
-
-    // Publish all messages
-    await Promise.all(messages.map((message) => this.publishMessage(message)));
-  }
-
-  private async publishMessage(message: TMessage): Promise<void> {
-    const command = new PublishCommand({
-      TopicArn: this.connection.topicArn,
-      Message: JSON.stringify({
-        type: message.type,
-        payload: message.payload,
-      }),
-      MessageAttributes: {
-        type: {
-          DataType: 'String',
-          StringValue: message.type,
-        },
-      },
-    });
-
-    await this.connection.snsClient.send(command);
-  }
-
-  async close(): Promise<void> {
-    // Publisher doesn't own the connection
-    // Connection should be closed by whoever created it
-  }
+	constructor(
+		private connection: SNSConnection,
+		_options: SNSPublisherOptions = {},
+	) {}
+
+	/**
+	 * Create an SNSPublisher from a connection string
+	 * Format: sns://?topicArn=arn:aws:sns:region:account:topic&region=us-east-1&endpoint=http://localhost:4566
+	 */
+	static async fromConnectionString<
+		TMessage extends PublishableMessage<string, any>,
+	>(connectionString: string): Promise<SNSPublisher<TMessage>> {
+		const { SNSConnection } = await import('./SNSConnection');
+		const connection =
+			await SNSConnection.fromConnectionString(connectionString);
+
+		return new SNSPublisher<TMessage>(connection);
+	}
+
+	async publish(messages: TMessage[]): Promise<void> {
+		if (messages.length === 0) return;
+
+		if (!this.connection.isConnected()) {
+			await this.connection.connect();
+		}
+
+		// Publish all messages
+		await Promise.all(messages.map((message) => this.publishMessage(message)));
+	}
+
+	private async publishMessage(message: TMessage): Promise<void> {
+		const command = new PublishCommand({
+			TopicArn: this.connection.topicArn,
+			Message: JSON.stringify({
+				type: message.type,
+				payload: message.payload,
+			}),
+			MessageAttributes: {
+				type: {
+					DataType: 'String',
+					StringValue: message.type,
+				},
+			},
+		});
+
+		await this.connection.snsClient.send(command);
+	}
+
+	async close(): Promise<void> {
+		// Publisher doesn't own the connection
+		// Connection should be closed by whoever created it
+	}
 }