@geekmidas/constructs 1.0.5 → 1.1.0

package/src/subscribers/TestSubscriberAdaptor.ts

@@ -0,0 +1,127 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type {
+	EventPublisher,
+	ExtractPublisherMessage,
+} from '@geekmidas/events';
+import type { Logger } from '@geekmidas/logger';
+import type { InferStandardSchema } from '@geekmidas/schema';
+import type { Service, ServiceRecord } from '@geekmidas/services';
+import { ServiceDiscovery } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { publishEvents } from '../publisher';
+import type { Subscriber } from './Subscriber';
+
+// Helper type to extract payload types for subscribed events
+type ExtractEventPayloads<
+	TPublisher extends EventPublisher<any> | undefined,
+	TEventTypes extends any[],
+> = TPublisher extends EventPublisher<any>
+	? Extract<ExtractPublisherMessage<TPublisher>, { type: TEventTypes[number] }>
+	: never;
+
+export class TestSubscriberAdaptor<
+	TServices extends Service[] = [],
+	TLogger extends Logger = Logger,
+	OutSchema extends StandardSchemaV1 | undefined = undefined,
+	TEventPublisher extends EventPublisher<any> | undefined = undefined,
+	TEventPublisherServiceName extends string = string,
+	TSubscribedEvents extends
+		ExtractPublisherMessage<TEventPublisher>['type'][] = ExtractPublisherMessage<TEventPublisher>['type'][],
+> {
+	static getDefaultServiceDiscovery() {
+		return ServiceDiscovery.getInstance(new EnvironmentParser({}));
+	}
+
+	constructor(
+		private readonly subscriber: Subscriber<
+			TServices,
+			TLogger,
+			OutSchema,
+			TEventPublisher,
+			TEventPublisherServiceName,
+			TSubscribedEvents
+		>,
+		private serviceDiscovery: ServiceDiscovery<any> = TestSubscriberAdaptor.getDefaultServiceDiscovery(),
+	) {}
+
+	async invoke(
+		request: TestSubscriberRequest<
+			TEventPublisher,
+			TSubscribedEvents,
+			TServices
+		>,
+	): Promise<InferStandardSchema<OutSchema>> {
+		// Create logger with test context
+		const logger = this.subscriber.logger.child({
+			test: true,
+		}) as TLogger;
+
+		// Resolve services (use provided or auto-register)
+		let services: ServiceRecord<TServices>;
+		if (request.services) {
+			services = request.services;
+		} else {
+			services = await this.serviceDiscovery.register(this.subscriber.services);
+		}
+
+		// Filter events to only subscribed types
+		const filteredEvents = this.filterEvents(request.events);
+
+		// Return early if no events after filtering (mirrors AWSLambdaSubscriber)
+		if (filteredEvents.length === 0) {
+			return { batchItemFailures: [] } as any;
+		}
+
+		// Execute the subscriber handler
+		const result = await this.subscriber.handler({
+			events: filteredEvents,
+			services,
+			logger,
+		});
+
+		// Validate output if schema is provided
+		let output = result;
+		if (this.subscriber.outputSchema && result) {
+			const validationResult =
+				await this.subscriber.outputSchema['~standard'].validate(result);
+
+			if (validationResult.issues) {
+				throw new Error('Subscriber output validation failed');
+			}
+
+			output = validationResult.value;
+		}
+
+		// Publish events if configured
+		await publishEvents(
+			logger,
+			this.serviceDiscovery,
+			this.subscriber.events,
+			output,
+			this.subscriber.publisherService,
+		);
+
+		return output;
+	}
+
+	private filterEvents(
+		events: ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[],
+	): ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[] {
+		if (!this.subscriber.subscribedEvents) {
+			return events;
+		}
+
+		return events.filter((event: any) =>
+			this.subscriber.subscribedEvents!.includes(event.type),
+		);
+	}
+}
+
+export type TestSubscriberRequest<
+	TEventPublisher extends EventPublisher<any> | undefined = undefined,
+	TSubscribedEvents extends any[] = [],
+	TServices extends Service[] = [],
+> = {
+	events: ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[];
+	services?: ServiceRecord<TServices>;
+};

package/src/subscribers/__tests__/AWSLambdaSubscriberAdaptor.spec.ts

@@ -662,41 +662,260 @@ describe('AWSLambdaSubscriber', () => {
 			);
 		});
 
-		it('should log errors for invalid SQS records', async () => {
-			const childLogger = {
-				info: vi.fn(),
-				error: vi.fn(),
-				warn: vi.fn(),
-				debug: vi.fn(),
-				child: vi.fn(),
+		it('should wrap non-JSON SNS message with type from MessageAttributes in SQS', async () => {
+			const handler = vi.fn(async ({ events }) => {
+				expect(events).toHaveLength(1);
+				expect(events[0]).toEqual({
+					type: 'notification.sent',
+					payload: 'this is not json',
+				});
+			});
+
+			const subscriber = new Subscriber(
+				handler,
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
+			);
+
+			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
+			const lambdaHandler = adapter.handler;
+
+			const sqsEvent: SQSEvent = {
+				Records: [
+					{
+						messageId: 'message-1',
+						receiptHandle: 'receipt-1',
+						body: JSON.stringify({
+							Type: 'Notification',
+							MessageId: 'sns-msg-1',
+							TopicArn: 'arn:aws:sns:region:account:topic',
+							Message: 'this is not json',
+							Timestamp: '2023-01-01T00:00:00.000Z',
+							MessageAttributes: {
+								type: { Type: 'String', Value: 'notification.sent' },
+							},
+						}),
+						attributes: {} as any,
+						messageAttributes: {},
+						md5OfBody: 'md5',
+						eventSource: 'aws:sqs',
+						eventSourceARN: 'arn:aws:sqs:region:account:queue-name',
+						awsRegion: 'us-east-1',
+					} as SQSRecord,
+				],
 			};
 
-			const mockLogger = {
-				child: vi.fn().mockReturnValue(childLogger),
-				info: vi.fn(),
-				error: vi.fn(),
-				warn: vi.fn(),
-				debug: vi.fn(),
+			await lambdaHandler(sqsEvent, createMockContext(), vi.fn());
+
+			expect(handler).toHaveBeenCalled();
+		});
+
+		it('should pass through non-JSON SNS message without type as raw string', async () => {
+			const handler = vi.fn(async ({ events }) => {
+				expect(events).toHaveLength(1);
+				expect(events[0]).toBe('plain text without type');
+			});
+
+			const subscriber = new Subscriber(
+				handler,
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
+			);
+
+			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
+			const lambdaHandler = adapter.handler;
+
+			const sqsEvent: SQSEvent = {
+				Records: [
+					{
+						messageId: 'message-1',
+						receiptHandle: 'receipt-1',
+						body: JSON.stringify({
+							Type: 'Notification',
+							MessageId: 'sns-msg-1',
+							TopicArn: 'arn:aws:sns:region:account:topic',
+							Message: 'plain text without type',
+							Timestamp: '2023-01-01T00:00:00.000Z',
+						}),
+						attributes: {} as any,
+						messageAttributes: {},
+						md5OfBody: 'md5',
+						eventSource: 'aws:sqs',
+						eventSourceARN: 'arn:aws:sqs:region:account:queue-name',
+						awsRegion: 'us-east-1',
+					} as SQSRecord,
+				],
 			};
 
+			await lambdaHandler(sqsEvent, createMockContext(), vi.fn());
+
+			expect(handler).toHaveBeenCalled();
+		});
+
+		it('should wrap non-JSON SNS record with type from MessageAttributes', async () => {
 			const handler = vi.fn(async ({ events }) => {
-				// Should still process valid events
 				expect(events).toHaveLength(1);
+				expect(events[0]).toEqual({
+					type: 'alert.fired',
+					payload: 'plain text, not json',
+				});
 			});
 
 			const subscriber = new Subscriber(
 				handler,
-				30000, // timeout
-				undefined, // subscribedEvents
-				undefined, // outputSchema
-				[], // services
-				mockLogger as any, // logger
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
+			);
+
+			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
+			const lambdaHandler = adapter.handler;
+
+			const snsEvent: SNSEvent = {
+				Records: [
+					{
+						EventSource: 'aws:sns',
+						EventVersion: '1.0',
+						EventSubscriptionArn: 'arn:aws:sns:region:account:topic',
+						Sns: {
+							Type: 'Notification',
+							MessageId: 'msg-1',
+							TopicArn: 'arn:aws:sns:region:account:topic',
+							Subject: 'Test',
+							Message: 'plain text, not json',
+							Timestamp: '2023-01-01T00:00:00.000Z',
+							SignatureVersion: '1',
+							Signature: 'sig',
+							SigningCertUrl: 'https://example.com/cert',
+							UnsubscribeUrl: 'https://example.com/unsub',
+							MessageAttributes: {
+								type: { Type: 'String', Value: 'alert.fired' },
+							},
+						},
+					} as SNSEventRecord,
+				],
+			};
+
+			await lambdaHandler(snsEvent, createMockContext(), vi.fn());
+
+			expect(handler).toHaveBeenCalled();
+		});
+
+		it('should pass through non-JSON SNS record without type as raw string', async () => {
+			const handler = vi.fn(async ({ events }) => {
+				expect(events).toHaveLength(1);
+				expect(events[0]).toBe('plain text, no type attr');
+			});
+
+			const subscriber = new Subscriber(
+				handler,
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
+			);
+
+			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
+			const lambdaHandler = adapter.handler;
+
+			const snsEvent: SNSEvent = {
+				Records: [
+					{
+						EventSource: 'aws:sns',
+						EventVersion: '1.0',
+						EventSubscriptionArn: 'arn:aws:sns:region:account:topic',
+						Sns: {
+							Type: 'Notification',
+							MessageId: 'msg-1',
+							TopicArn: 'arn:aws:sns:region:account:topic',
+							Subject: 'Test',
+							Message: 'plain text, no type attr',
+							Timestamp: '2023-01-01T00:00:00.000Z',
+							SignatureVersion: '1',
+							Signature: 'sig',
+							SigningCertUrl: 'https://example.com/cert',
+							UnsubscribeUrl: 'https://example.com/unsub',
+						},
+					} as SNSEventRecord,
+				],
+			};
+
+			await lambdaHandler(snsEvent, createMockContext(), vi.fn());
+
+			expect(handler).toHaveBeenCalled();
+		});
+
+		it('should pass through non-JSON SQS body', async () => {
+			const handler = vi.fn(async ({ events }) => {
+				expect(events).toHaveLength(1);
+				expect(events[0]).toBe('raw text body');
+			});
+
+			const subscriber = new Subscriber(
+				handler,
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
+			);
+
+			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
+			const lambdaHandler = adapter.handler;
+
+			const sqsEvent: SQSEvent = {
+				Records: [
+					{
+						messageId: 'message-1',
+						receiptHandle: 'receipt-1',
+						body: 'raw text body',
+						attributes: {} as any,
+						messageAttributes: {},
+						md5OfBody: 'md5',
+						eventSource: 'aws:sqs',
+						eventSourceARN: 'arn:aws:sqs:region:account:queue-name',
+						awsRegion: 'us-east-1',
+					} as SQSRecord,
+				],
+			};
+
+			await lambdaHandler(sqsEvent, createMockContext(), vi.fn());
+
+			expect(handler).toHaveBeenCalled();
+		});
+
+		it('should pass through invalid JSON SQS records alongside valid ones', async () => {
+			const handler = vi.fn(async ({ events }) => {
+				// Both records should be passed through
+				expect(events).toHaveLength(2);
+				expect(events[0]).toBe('invalid json{');
+				expect(events[1]).toEqual({
+					type: 'user.created',
+					payload: { userId: '1', email: 'user1@example.com' },
+				});
+			});
+
+			const subscriber = new Subscriber(
+				handler,
+				30000,
+				undefined,
+				undefined,
+				[],
+				logger,
 			);
 
 			const adapter = new AWSLambdaSubscriber(envParser, subscriber);
 			const lambdaHandler = adapter.handler;
 
-			// Create event with one invalid record
 			const sqsEvent: SQSEvent = {
 				Records: [
 					{
@@ -729,13 +948,6 @@ describe('AWSLambdaSubscriber', () => {
 
 			await lambdaHandler(sqsEvent, createMockContext(), vi.fn());
 
-			expect(childLogger.error).toHaveBeenCalledWith(
-				expect.objectContaining({
-					error: expect.any(Error),
-					record: expect.any(Object),
-				}),
-				'Failed to parse SQS record body',
-			);
 			expect(handler).toHaveBeenCalled();
 		});
 	});