@geekmidas/constructs 0.0.1

package/src/subscribers/AWSLambdaSubscriberAdaptor.ts

@@ -0,0 +1,269 @@
+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 { Service, ServiceRecord } from '@geekmidas/services';
+import { ServiceDiscovery } from '@geekmidas/services';
+import middy, { type MiddlewareObj } from '@middy/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type {
+  Context,
+  Handler,
+  SNSEvent,
+  SQSEvent,
+  SQSRecord,
+} from 'aws-lambda';
+
+import type { InferStandardSchema } from '@geekmidas/schema';
+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.logger,
+      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 rawEvent = (req as any).event as SQSEvent | SNSEvent;
+
+        // 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 (event && this.isSubscribedEvent(event.type)) {
+                  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 = JSON.parse(record.Sns.Message);
+                if (event && this.isSubscribedEvent(event.type)) {
+                  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 {
+    return (
+      'Records' in event &&
+      event.Records.length > 0 &&
+      'eventSource' in event.Records[0] &&
+      event.Records[0].eventSource === 'aws:sqs'
+    );
+  }
+
+  private isSNSEvent(event: SQSEvent | SNSEvent): event is SNSEvent {
+    return (
+      'Records' in event &&
+      event.Records.length > 0 &&
+      'EventSource' in event.Records[0] &&
+      event.Records[0].EventSource === 'aws:sns'
+    );
+  }
+
+  private parseSQSRecord(record: SQSRecord): any | null {
+    try {
+      const body = JSON.parse(record.body);
+
+      // Check if this is an SNS message wrapped in SQS
+      if (body.Type === 'Notification' && body.Message) {
+        // Parse the SNS message
+        const snsMessage = JSON.parse(body.Message);
+        return snsMessage;
+      }
+
+      // Direct SQS message
+      return body;
+    } catch (error) {
+      this.logger.error({ error, record }, 'Failed to parse SQS record body');
+      return null;
+    }
+  }
+
+  private isSubscribedEvent(eventType: string): boolean {
+    if (!this.subscriber.subscribedEvents) {
+      return true; // If no events specified, accept all
+    }
+
+    return this.subscriber.subscribedEvents.includes(eventType 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
+    return middy(handler)
+      .use(this.loggerMiddleware())
+      .use(this.error())
+      .use(this.services())
+      .use(this.parseEvents()) as unknown as AWSLambdaHandler;
+  }
+}

package/src/subscribers/Subscriber.ts

@@ -0,0 +1,112 @@
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import { Construct, ConstructType } from '../Construct';
+
+import type {
+  EventPublisher,
+  ExtractPublisherMessage,
+} from '@geekmidas/events';
+import type { InferStandardSchema } from '@geekmidas/schema';
+import type { Service, ServiceRecord } from '@geekmidas/services';
+
+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 readonly timeout: number = 30000,
+    protected _subscribedEvents?: TSubscribedEvents,
+    public readonly outputSchema?: OutSchema,
+    public readonly services: TServices = [] as unknown as TServices,
+    public readonly logger: TLogger = DEFAULT_LOGGER as TLogger,
+    public readonly publisherService?: Service<
+      TEventPublisherServiceName,
+      TEventPublisher
+    >,
+  ) {
+    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

@@ -0,0 +1,150 @@
+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 { 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>;
+
+  constructor() {
+    this._timeout = 30000; // Default timeout
+  }
+
+  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,
+    );
+
+    // Reset builder state after creating the subscriber to prevent pollution
+    this._services = [] as Service[] as TServices;
+    this._logger = DEFAULT_LOGGER;
+    this._publisher = undefined;
+    this._subscribedEvents = [] as any;
+    this._timeout = 30000; // Reset to default
+    this.outputSchema = undefined;
+
+    return subscriber;
+  }
+}