@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/subscribers/AWSLambdaSubscriberAdaptor.ts

@@ -1,342 +0,0 @@
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import { wrapError } from '@geekmidas/errors';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type { InferStandardSchema } from '@geekmidas/schema';
-import type { Service, ServiceRecord } from '@geekmidas/services';
-import { runWithRequestContext, ServiceDiscovery } from '@geekmidas/services';
-import middy, { type MiddlewareObj } from '@middy/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type {
-	Context,
-	Handler,
-	SNSEvent,
-	SNSEventRecord,
-	SQSEvent,
-	SQSRecord,
-} from 'aws-lambda';
-import type { Subscriber } from './Subscriber';
-
-export type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<
-	TEvent,
-	TResult
->;
-
-type SubscriberEvent<TServices extends Service[], TLogger extends Logger> = {
-	events: any[];
-	services: ServiceRecord<TServices>;
-	logger: TLogger;
-};
-
-type Middleware<
-	TServices extends Service[],
-	TLogger extends Logger,
-	TOutSchema extends StandardSchemaV1 | undefined,
-> = MiddlewareObj<
-	SubscriberEvent<TServices, TLogger>,
-	InferStandardSchema<TOutSchema>,
-	Error,
-	Context
->;
-
-export class AWSLambdaSubscriber<
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TSubscribedEvents extends any[] = [],
-> {
-	private _logger!: TLogger;
-	private _services!: ServiceRecord<TServices>;
-
-	constructor(
-		private envParser: EnvironmentParser<{}>,
-		readonly subscriber: Subscriber<
-			TServices,
-			TLogger,
-			OutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TSubscribedEvents
-		>,
-	) {
-		this._logger = subscriber.logger;
-	}
-
-	get logger(): TLogger {
-		return this._logger;
-	}
-
-	private async getServices(): Promise<ServiceRecord<TServices>> {
-		if (this._services) {
-			return this._services;
-		}
-
-		const serviceDiscovery = ServiceDiscovery.getInstance(this.envParser);
-
-		if (this.subscriber.services.length > 0) {
-			const registered = await serviceDiscovery.register(
-				this.subscriber.services,
-			);
-			this._services = registered as ServiceRecord<TServices>;
-		} else {
-			this._services = {} as ServiceRecord<TServices>;
-		}
-
-		return this._services;
-	}
-
-	private error(): Middleware<TServices, TLogger, OutSchema> {
-		return {
-			onError: (req) => {
-				const logger = req.event?.logger || this.subscriber.logger;
-				logger.error(req.error || {}, 'Error processing subscriber');
-
-				// Re-throw the wrapped error to let Lambda handle it
-				throw wrapError(req.error);
-			},
-		};
-	}
-
-	private loggerMiddleware(): Middleware<TServices, TLogger, OutSchema> {
-		return {
-			before: (req) => {
-				this._logger = this.subscriber.logger.child({
-					subscriber: {
-						name: req.context.functionName,
-						version: req.context.functionVersion,
-						memory: req.context.memoryLimitInMB,
-					},
-					req: {
-						id: req.context.awsRequestId,
-					},
-				}) as TLogger;
-
-				req.event.logger = this._logger;
-			},
-		};
-	}
-
-	private services(): Middleware<TServices, TLogger, OutSchema> {
-		return {
-			before: async (req) => {
-				req.event.services = await this.getServices();
-			},
-		};
-	}
-
-	private parseEvents(): Middleware<TServices, TLogger, OutSchema> {
-		return {
-			before: async (req) => {
-				const { logger, ...e } = req.event;
-				const rawEvent = e as any as SQSEvent | SNSEvent;
-
-				logger.info({
-					rawEvent,
-				});
-
-				// Parse events based on the event type
-				const events: any[] = [];
-
-				if ('Records' in rawEvent) {
-					if (this.isSQSEvent(rawEvent)) {
-						// SQS Event
-						for (const record of rawEvent.Records) {
-							try {
-								const event = this.parseSQSRecord(record);
-								if (this.shouldIncludeEvent(event)) {
-									events.push(event);
-								}
-							} catch (error) {
-								this.logger.error(
-									{ error, record },
-									'Failed to parse SQS record',
-								);
-							}
-						}
-					} else if (this.isSNSEvent(rawEvent)) {
-						// SNS Event
-						for (const record of rawEvent.Records) {
-							try {
-								const event = this.parseSNSRecord(record);
-								if (this.shouldIncludeEvent(event)) {
-									events.push(event);
-								}
-							} catch (error) {
-								this.logger.error(
-									{ error, record },
-									'Failed to parse SNS record',
-								);
-							}
-						}
-					}
-				}
-
-				(req.event as any).events = events;
-			},
-		};
-	}
-
-	private isSQSEvent(event: SQSEvent | SNSEvent): event is SQSEvent {
-		const firstRecord = event.Records[0];
-		return (
-			'Records' in event &&
-			event.Records.length > 0 &&
-			firstRecord !== undefined &&
-			'eventSource' in firstRecord &&
-			firstRecord.eventSource === 'aws:sqs'
-		);
-	}
-
-	private isSNSEvent(event: SQSEvent | SNSEvent): event is SNSEvent {
-		const firstRecord = event.Records[0];
-		return (
-			'Records' in event &&
-			event.Records.length > 0 &&
-			firstRecord !== undefined &&
-			'EventSource' in firstRecord &&
-			firstRecord.EventSource === 'aws:sns'
-		);
-	}
-
-	private parseSNSRecord(record: SNSEventRecord): any {
-		const message = this.safeJsonParse(record.Sns.Message);
-		const messageType = record.Sns.MessageAttributes?.type?.Value;
-
-		// Not JSON — wrap raw string with type from MessageAttributes if available
-		if (message === null) {
-			return messageType
-				? { type: messageType, payload: record.Sns.Message }
-				: record.Sns.Message;
-		}
-
-		// Resolve type from MessageAttributes (preferred) or message body
-		const resolvedType = messageType ?? message.type;
-
-		if (message.type) {
-			return message; // Full event format: { type, payload }
-		}
-
-		// Payload-only format: type is in MessageAttributes
-		return resolvedType ? { type: resolvedType, payload: message } : message;
-	}
-
-	private parseSQSRecord(record: SQSRecord): any {
-		const body = this.safeJsonParse(record.body);
-
-		// Not JSON — return raw body as-is
-		if (body === null) {
-			return record.body;
-		}
-
-		// Check if this is an SNS message wrapped in SQS
-		if (body.Type === 'Notification' && body.Message) {
-			const snsMessage = this.safeJsonParse(body.Message);
-			const messageType = body.MessageAttributes?.type?.Value;
-
-			// SNS Message not JSON — wrap with type from MessageAttributes if available
-			if (snsMessage === null) {
-				return messageType
-					? { type: messageType, payload: body.Message }
-					: body.Message;
-			}
-
-			if (snsMessage.type) {
-				return snsMessage; // Full event format: { type, payload }
-			}
-
-			// Payload-only format: type is in MessageAttributes
-			const resolvedType = messageType ?? snsMessage.type;
-			return resolvedType
-				? { type: resolvedType, payload: snsMessage }
-				: snsMessage;
-		}
-
-		// Direct SQS message
-		return body;
-	}
-
-	private safeJsonParse(value: string): any | null {
-		try {
-			return JSON.parse(value);
-		} catch {
-			return null;
-		}
-	}
-
-	private shouldIncludeEvent(event: any): boolean {
-		// No event type (raw string/non-object) — always include
-		if (typeof event !== 'object' || !event?.type) {
-			return true;
-		}
-
-		// No filter configured — accept all
-		if (!this.subscriber.subscribedEvents) {
-			return true;
-		}
-
-		return this.subscriber.subscribedEvents.includes(event.type as any);
-	}
-
-	private async _handler(event: SubscriberEvent<TServices, TLogger>) {
-		// If no events after filtering, return early
-		if (event.events.length === 0) {
-			this.logger.info('No subscribed events to process');
-			return {
-				batchItemFailures: [],
-			};
-		}
-
-		// Execute the subscriber with the parsed context
-		const result = await this.subscriber.handler({
-			events: event.events,
-			services: event.services,
-			logger: event.logger,
-		});
-
-		// Parse output if schema is provided
-		if (this.subscriber.outputSchema && result) {
-			const validationResult =
-				await this.subscriber.outputSchema['~standard'].validate(result);
-
-			if (validationResult.issues) {
-				this.logger.error(
-					{ issues: validationResult.issues },
-					'Subscriber output validation failed',
-				);
-				throw new Error('Subscriber output validation failed');
-			}
-
-			return validationResult.value;
-		}
-
-		return result;
-	}
-
-	get handler(): AWSLambdaHandler {
-		const handler = this._handler.bind(this);
-
-		// Apply middleware in order
-		const chain = middy(handler)
-			.use(this.loggerMiddleware())
-			.use(this.parseEvents())
-			.use(this.error())
-			.use(this.services());
-
-		// Wrap entire Middy chain in request context for service access
-		const wrappedHandler = async (event: unknown, context: Context) => {
-			const startTime = Date.now();
-			const requestId = context.awsRequestId;
-			const logger = this.subscriber.logger.child({
-				requestId,
-			}) as TLogger;
-
-			return runWithRequestContext({ logger, requestId, startTime }, () =>
-				chain(event as Parameters<typeof chain>[0], context),
-			);
-		};
-
-		return wrappedHandler as unknown as AWSLambdaHandler;
-	}
-}

package/src/subscribers/Subscriber.ts

@@ -1,117 +0,0 @@
-import type {
-	EventPublisher,
-	ExtractPublisherMessage,
-} from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { InferStandardSchema } from '@geekmidas/schema';
-import type { Service, ServiceRecord } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { Construct, ConstructType } from '../Construct';
-
-const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
-// 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 Subscriber<
-	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'][],
-> extends Construct<
-	TLogger,
-	TEventPublisherServiceName,
-	TEventPublisher,
-	OutSchema,
-	TServices
-> {
-	__IS_SUBSCRIBER__ = true;
-
-	static isSubscriber(
-		obj: any,
-	): obj is Subscriber<any, any, any, any, any, any> {
-		return Boolean(
-			obj &&
-				obj.__IS_SUBSCRIBER__ === true &&
-				obj.type === ConstructType.Subscriber,
-		);
-	}
-
-	constructor(
-		public readonly handler: SubscriberHandler<
-			TEventPublisher,
-			TSubscribedEvents,
-			TServices,
-			TLogger,
-			OutSchema
-		>,
-		public override readonly timeout: number = 30000,
-		protected _subscribedEvents?: TSubscribedEvents,
-		public override readonly outputSchema?: OutSchema,
-		public override readonly services: TServices = [] as unknown as TServices,
-		public override readonly logger: TLogger = DEFAULT_LOGGER as TLogger,
-		public override readonly publisherService?: Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>,
-		/**
-		 * The name of the {@link Topic} this subscriber binds to (via
-		 * `s.topic(topic)`), recorded for the manifest so infra wires the SNS
-		 * subscription. Undefined when the subscriber's events are typed from a
-		 * (hand-written) publisher instead.
-		 */
-		public readonly topicName?: string,
-	) {
-		super(
-			ConstructType.Subscriber,
-			logger,
-			services,
-			[],
-			publisherService,
-			outputSchema,
-		);
-	}
-
-	get subscribedEvents(): TSubscribedEvents | undefined {
-		return this._subscribedEvents;
-	}
-}
-
-// Handler type for subscribers that receives an array of events
-export type SubscriberHandler<
-	TEventPublisher extends EventPublisher<any> | undefined,
-	TSubscribedEvents extends ExtractPublisherMessage<TEventPublisher>['type'][],
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-> = (
-	ctx: SubscriberContext<
-		TEventPublisher,
-		TSubscribedEvents,
-		TServices,
-		TLogger
-	>,
-) => OutSchema extends StandardSchemaV1
-	? InferStandardSchema<OutSchema> | Promise<InferStandardSchema<OutSchema>>
-	: any | Promise<any>;
-
-// Context type for subscriber handlers
-export type SubscriberContext<
-	TEventPublisher extends EventPublisher<any> | undefined,
-	TSubscribedEvents extends ExtractPublisherMessage<TEventPublisher>['type'][],
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-> = {
-	events: ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[];
-	services: ServiceRecord<TServices>;
-	logger: TLogger;
-};

package/src/subscribers/SubscriberBuilder.ts

@@ -1,186 +0,0 @@
-import type {
-	EventPublisher,
-	ExtractPublisherMessage,
-} from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import { DEFAULT_LOGGER } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Topic, TopicEvents, TopicMessage } from '../topic/Topic';
-import { Subscriber, type SubscriberHandler } from './Subscriber';
-
-export class SubscriberBuilder<
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TSubscribedEvents extends any[] = [],
-> {
-	private _subscribedEvents: TSubscribedEvents = [] as any;
-	private _timeout?: number;
-	private outputSchema?: OutSchema;
-	private _services: TServices = [] as Service[] as TServices;
-	private _logger: TLogger = DEFAULT_LOGGER;
-	private _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
-	private _topicName?: string;
-
-	constructor() {
-		this._timeout = 30000; // Default timeout
-	}
-
-	/**
-	 * Bind this subscriber to a {@link Topic} — the preferred way to type and wire
-	 * a fan-out consumer. It supplies the subscribable event types (and their
-	 * payloads) from the topic's contract and records the binding for the manifest,
-	 * so infra wires the SNS subscription.
-	 *
-	 * Prefer this over typing via a hand-written publisher service: a consumer does
-	 * not publish, so binding a topic does *not* require the topic's publisher
-	 * connection string (least privilege). Use `.publisher(...)` only when the
-	 * subscriber actually publishes follow-up events.
-	 */
-	topic<TName extends string, TEvents extends TopicEvents>(
-		topic: Topic<TName, TEvents>,
-	): SubscriberBuilder<
-		TServices,
-		TLogger,
-		OutSchema,
-		EventPublisher<TopicMessage<TEvents>>,
-		TEventPublisherServiceName,
-		TSubscribedEvents
-	> {
-		this._topicName = topic.name;
-		return this as unknown as SubscriberBuilder<
-			TServices,
-			TLogger,
-			OutSchema,
-			EventPublisher<TopicMessage<TEvents>>,
-			TEventPublisherServiceName,
-			TSubscribedEvents
-		>;
-	}
-
-	timeout(timeout: number): this {
-		this._timeout = timeout;
-		return this;
-	}
-
-	output<T extends StandardSchemaV1>(
-		schema: T,
-	): SubscriberBuilder<
-		TServices,
-		TLogger,
-		T,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TSubscribedEvents
-	> {
-		this.outputSchema = schema as unknown as OutSchema;
-		return this as any;
-	}
-
-	services<T extends Service[]>(
-		services: T,
-	): SubscriberBuilder<
-		[...TServices, ...T],
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TSubscribedEvents
-	> {
-		this._services = [...this._services, ...services] as any;
-		return this as any;
-	}
-
-	logger<T extends Logger>(
-		logger: T,
-	): SubscriberBuilder<
-		TServices,
-		T,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TSubscribedEvents
-	> {
-		this._logger = logger as unknown as TLogger;
-		return this as any;
-	}
-
-	publisher<T extends EventPublisher<any>, TName extends string>(
-		publisher: Service<TName, T>,
-	): SubscriberBuilder<
-		TServices,
-		TLogger,
-		OutSchema,
-		T,
-		TName,
-		TSubscribedEvents
-	> {
-		this._publisher = publisher as any;
-		return this as any;
-	}
-
-	subscribe<
-		TEvent extends TEventPublisher extends EventPublisher<any>
-			?
-					| ExtractPublisherMessage<TEventPublisher>['type']
-					| ExtractPublisherMessage<TEventPublisher>['type'][]
-			: never,
-	>(
-		event: TEvent,
-	): SubscriberBuilder<
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TEvent extends any[]
-			? [...TSubscribedEvents, ...TEvent]
-			: [...TSubscribedEvents, TEvent]
-	> {
-		const eventsToAdd = Array.isArray(event) ? event : [event];
-		this._subscribedEvents = [...this._subscribedEvents, ...eventsToAdd] as any;
-		return this as any;
-	}
-
-	handle(
-		fn: SubscriberHandler<
-			TEventPublisher,
-			TSubscribedEvents,
-			TServices,
-			TLogger,
-			OutSchema
-		>,
-	): Subscriber<
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TSubscribedEvents
-	> {
-		const subscriber = new Subscriber(
-			fn,
-			this._timeout,
-			this._subscribedEvents,
-			this.outputSchema,
-			this._services,
-			this._logger,
-			this._publisher,
-			this._topicName,
-		);
-
-		// Reset builder state after creating the subscriber to prevent pollution
-		this._services = [] as Service[] as TServices;
-		this._logger = DEFAULT_LOGGER;
-		this._publisher = undefined;
-		this._topicName = undefined;
-		this._subscribedEvents = [] as any;
-		this._timeout = 30000; // Reset to default
-		this.outputSchema = undefined;
-
-		return subscriber;
-	}
-}