@geekmidas/constructs 0.0.1

package/src/endpoints/AmazonApiGatewayEndpointAdaptor.ts

@@ -0,0 +1,315 @@
+import type { Logger } from '@geekmidas/logger';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { HttpMethod } from '../types';
+import { Endpoint, type EndpointSchemas } from './Endpoint';
+
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import middy, { type MiddlewareObj } from '@middy/core';
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  Context,
+} from 'aws-lambda';
+import set from 'lodash.set';
+
+import {
+  UnauthorizedError,
+  UnprocessableEntityError,
+  wrapError,
+} from '@geekmidas/errors';
+import type { EventPublisher } from '@geekmidas/events';
+import {
+  type Service,
+  ServiceDiscovery,
+  type ServiceRecord,
+} from '@geekmidas/services';
+
+import type {
+  InferComposableStandardSchema,
+  InferStandardSchema,
+} from '@geekmidas/schema';
+import { publishConstructEvents } from '../publisher';
+
+// Helper function to publish events
+
+export abstract class AmazonApiGatewayEndpoint<
+  THandler extends
+    | AmazonApiGatewayV1EndpointHandler
+    | AmazonApiGatewayV2EndpointHandler,
+  TEvent extends HandlerEvent<THandler>,
+  TRoute extends string,
+  TMethod extends HttpMethod,
+  TInput extends EndpointSchemas = {},
+  TOutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> {
+  constructor(
+    protected envParser: EnvironmentParser<{}>,
+    protected readonly endpoint: Endpoint<
+      TRoute,
+      TMethod,
+      TInput,
+      TOutSchema,
+      TServices,
+      TLogger,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ) {}
+
+  private error(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      onError: (req) => {
+        (req.event.logger || this.endpoint.logger).error(
+          req.error || {},
+          'Error processing request',
+        );
+        const wrappedError = wrapError(req.error);
+
+        // Set the response with the proper status code from the HttpError
+        req.response = {
+          statusCode: wrappedError.statusCode,
+          body: wrappedError.body,
+        };
+      },
+    };
+  }
+  abstract getInput(e: TEvent): GetInputResponse;
+
+  private input(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      before: async (req) => {
+        try {
+          const { body, query, params } = this.getInput(req.event);
+          const headers = req.event.headers as Record<string, string>;
+          const header = Endpoint.createHeaders(headers);
+
+          set(req.event, 'body', await this.endpoint.parseInput(body, 'body'));
+
+          set(
+            req.event,
+            'query',
+            await this.endpoint.parseInput(query, 'query'),
+          );
+          set(
+            req.event,
+            'params',
+            await this.endpoint.parseInput(params, 'params'),
+          );
+          set(req.event, 'header', header);
+        } catch (error) {
+          // Convert validation errors to 422 Unprocessable Entity
+          if (error && typeof error === 'object' && Array.isArray(error)) {
+            throw new UnprocessableEntityError('Validation failed', error);
+          }
+          throw error;
+        }
+      },
+    };
+  }
+
+  abstract getLoggerContext(data: TEvent, context: Context): LoggerContext;
+
+  private logger(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      before: (req) => {
+        req.event.logger = this.endpoint.logger.child({
+          route: this.endpoint.route,
+          host: req.event.headers?.host,
+          method: this.endpoint.method,
+          ...this.getLoggerContext(req.event, req.context),
+        }) as TLogger;
+      },
+    };
+  }
+  private services(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      before: async (req) => {
+        const logger = req.event.logger as TLogger;
+        const serviceDiscovery = ServiceDiscovery.getInstance<
+          ServiceRecord<TServices>,
+          TLogger
+        >(logger, this.envParser);
+
+        const services = await serviceDiscovery.register(
+          this.endpoint.services,
+        );
+
+        req.event.services = services;
+      },
+    };
+  }
+
+  private authorize(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      before: async (req) => {
+        const logger = req.event.logger as TLogger;
+        const services = req.event.services;
+        const header = req.event.header;
+        const session = req.event.session as TSession;
+
+        const isAuthorized = await this.endpoint.authorize({
+          header,
+          services,
+          logger,
+          session,
+        });
+
+        if (!isAuthorized) {
+          logger.warn('Unauthorized access attempt');
+          throw new UnauthorizedError(
+            'Unauthorized access to the endpoint',
+            'You do not have permission to access this resource.',
+          );
+        }
+      },
+    };
+  }
+
+  private session(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      before: async (req) => {
+        const logger = req.event.logger as TLogger;
+        const services = req.event.services;
+        req.event.session = (await this.endpoint.getSession({
+          logger,
+          services,
+          header: req.event.header,
+        })) as TSession;
+      },
+    };
+  }
+
+  private events(): Middleware<TEvent, TInput, TServices, TLogger> {
+    return {
+      after: async (req) => {
+        const event = req.event;
+        const response = (event as any)
+          .__response as InferStandardSchema<TOutSchema>;
+        const statusCode = req.response?.statusCode ?? this.endpoint.status;
+
+        // Only publish events on successful responses (2xx status codes)
+        if (Endpoint.isSuccessStatus(statusCode)) {
+          const logger = event.logger as TLogger;
+          const serviceDiscovery = ServiceDiscovery.getInstance<
+            ServiceRecord<TServices>,
+            TLogger
+          >(logger, this.envParser);
+          await publishConstructEvents(
+            this.endpoint,
+            response,
+            serviceDiscovery,
+            logger,
+          );
+        }
+      },
+    };
+  }
+
+  private async _handler(
+    event: Event<TEvent, TInput, TServices, TLogger, TSession>,
+  ) {
+    const input = this.endpoint.refineInput(event);
+
+    const response = await this.endpoint.handler({
+      header: event.header,
+      logger: event.logger,
+      services: event.services,
+      session: event.session,
+      ...input,
+    });
+
+    const output = await this.endpoint.parseOutput(response);
+
+    const body = output ? JSON.stringify(output) : undefined;
+
+    // Store response for middleware access
+    (event as any).__response = response;
+
+    return {
+      statusCode: this.endpoint.status,
+      body,
+    };
+  }
+
+  get handler() {
+    const handler = this._handler.bind(this);
+    return middy(handler)
+      .use(this.logger())
+      .use(this.error())
+      .use(this.services())
+      .use(this.input())
+      .use(this.session())
+      .use(this.authorize())
+      .use(this.events()) as unknown as THandler;
+  }
+}
+
+export type Event<
+  TEvent extends APIGatewayProxyEvent | APIGatewayProxyEventV2,
+  TInput extends EndpointSchemas = {},
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+> = {
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+  header(key: string): string | undefined;
+  session: TSession;
+} & TEvent &
+  InferComposableStandardSchema<TInput>;
+
+type Middleware<
+  TEvent extends APIGatewayProxyEvent | APIGatewayProxyEventV2,
+  TInput extends EndpointSchemas = {},
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+> = MiddlewareObj<Event<TEvent, TInput, TServices, TLogger, TSession>>;
+
+export type AmazonApiGatewayEndpointHandlerResponse = {
+  statusCode: number;
+  body: string | undefined;
+};
+
+export type LoggerContext = {
+  fn: {
+    name: string;
+    version: string;
+  };
+  req: {
+    id: string | undefined;
+    awsRequestId: string;
+    path: string;
+    ip: string | undefined;
+    userAgent: string | undefined;
+  };
+};
+
+export type GetInputResponse = {
+  body: any;
+  query: any;
+  params: any;
+};
+
+export type AmazonApiGatewayV1EndpointHandler = (
+  event: APIGatewayProxyEvent,
+  context: Context,
+) => Promise<AmazonApiGatewayEndpointHandlerResponse>;
+
+export type AmazonApiGatewayV2EndpointHandler = (
+  event: APIGatewayProxyEventV2,
+  context: Context,
+) => Promise<AmazonApiGatewayEndpointHandlerResponse>;
+
+export type HandlerEvent<T extends Function> = T extends (
+  event: infer E,
+  context: Context,
+) => any
+  ? E
+  : never;

package/src/endpoints/AmazonApiGatewayV1EndpointAdaptor.ts

@@ -0,0 +1,101 @@
+import type { Logger } from '@geekmidas/logger';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { HttpMethod } from '../types';
+import type { Endpoint, EndpointSchemas } from './Endpoint';
+
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
+
+import type { EventPublisher } from '@geekmidas/events';
+import type { Service } from '@geekmidas/services';
+import {
+  AmazonApiGatewayEndpoint,
+  type AmazonApiGatewayV1EndpointHandler,
+  type GetInputResponse,
+  type LoggerContext,
+} from './AmazonApiGatewayEndpointAdaptor';
+import { parseQueryParams } from './parseQueryParams';
+
+export class AmazonApiGatewayV1Endpoint<
+  TRoute extends string,
+  TMethod extends HttpMethod,
+  TInput extends EndpointSchemas = {},
+  TOutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+> extends AmazonApiGatewayEndpoint<
+  AmazonApiGatewayV1EndpointHandler,
+  APIGatewayProxyEvent,
+  TRoute,
+  TMethod,
+  TInput,
+  TOutSchema,
+  TServices,
+  TLogger,
+  TSession,
+  TEventPublisher
+> {
+  getInput(e: APIGatewayProxyEvent): GetInputResponse {
+    // For arrays, AWS API Gateway V1 provides multiValueQueryStringParameters
+    const multiValueParams = e.multiValueQueryStringParameters || {};
+    const singleValueParams = e.queryStringParameters || {};
+
+    // Merge single and multi-value parameters
+    const mergedParams: Record<string, string | string[]> = {};
+
+    // Add single value parameters
+    for (const [key, value] of Object.entries(singleValueParams)) {
+      if (value !== undefined) {
+        mergedParams[key] = value;
+      }
+    }
+
+    // Override with multi-value parameters where applicable
+    for (const [key, values] of Object.entries(multiValueParams)) {
+      if (values && values.length > 1) {
+        mergedParams[key] = values;
+      }
+    }
+
+    return {
+      body: e.body ? JSON.parse(e.body) : undefined,
+      query: parseQueryParams(mergedParams),
+      params: e.pathParameters || {},
+    };
+  }
+  getLoggerContext(
+    data: APIGatewayProxyEvent,
+    context: Context,
+  ): LoggerContext {
+    return {
+      fn: {
+        name: context.functionName,
+        version: context.functionVersion,
+      },
+      req: {
+        id: data.requestContext.requestId,
+        awsRequestId: context.awsRequestId,
+        ip: data.requestContext.identity.sourceIp,
+        userAgent: data.requestContext.identity.userAgent || undefined,
+        path: data.requestContext.path,
+      },
+    };
+  }
+  constructor(
+    protected envParser: EnvironmentParser<{}>,
+    protected readonly endpoint: Endpoint<
+      TRoute,
+      TMethod,
+      TInput,
+      TOutSchema,
+      TServices,
+      TLogger,
+      TSession,
+      TEventPublisher
+    >,
+  ) {
+    super(envParser, endpoint);
+  }
+}

package/src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts

@@ -0,0 +1,95 @@
+import type { Logger } from '@geekmidas/logger';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { HttpMethod } from '../types';
+import type { Endpoint, EndpointSchemas } from './Endpoint';
+
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { EventPublisher } from '@geekmidas/events';
+import type { Service } from '@geekmidas/services';
+import type { APIGatewayProxyEventV2, Context } from 'aws-lambda';
+import {
+  AmazonApiGatewayEndpoint,
+  type AmazonApiGatewayV2EndpointHandler,
+  type GetInputResponse,
+  type LoggerContext,
+} from './AmazonApiGatewayEndpointAdaptor';
+import { parseQueryParams } from './parseQueryParams';
+
+export class AmazonApiGatewayV2Endpoint<
+  TRoute extends string,
+  TMethod extends HttpMethod,
+  TInput extends EndpointSchemas = {},
+  TOutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TSession = unknown,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+> extends AmazonApiGatewayEndpoint<
+  AmazonApiGatewayV2EndpointHandler,
+  APIGatewayProxyEventV2,
+  TRoute,
+  TMethod,
+  TInput,
+  TOutSchema,
+  TServices,
+  TLogger,
+  TSession,
+  TEventPublisher
+> {
+  getInput(e: APIGatewayProxyEventV2): GetInputResponse {
+    // API Gateway V2 handles arrays as comma-separated values
+    const queryParams = e.queryStringParameters || {};
+    const processedParams: Record<string, string | string[]> = {};
+
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (value !== undefined) {
+        // Check if value contains comma and could be an array
+        // Be careful not to split values that legitimately contain commas
+        if (value.includes(',') && !value.includes('"')) {
+          processedParams[key] = value.split(',').map((v) => v.trim());
+        } else {
+          processedParams[key] = value;
+        }
+      }
+    }
+
+    return {
+      body: e.body ? JSON.parse(e.body) : undefined,
+      query: parseQueryParams(processedParams),
+      params: e.pathParameters || {},
+    };
+  }
+  getLoggerContext(
+    event: APIGatewayProxyEventV2,
+    context: Context,
+  ): LoggerContext {
+    return {
+      fn: {
+        name: context.functionName,
+        version: context.functionVersion,
+      },
+      req: {
+        id: event.requestContext.requestId,
+        awsRequestId: context.awsRequestId,
+        ip: event.requestContext.http.sourceIp,
+        userAgent: event.requestContext.http.userAgent || undefined,
+        path: event.requestContext.http.path,
+      },
+    };
+  }
+  constructor(
+    protected envParser: EnvironmentParser<{}>,
+    protected readonly endpoint: Endpoint<
+      TRoute,
+      TMethod,
+      TInput,
+      TOutSchema,
+      TServices,
+      TLogger,
+      TSession,
+      TEventPublisher
+    >,
+  ) {
+    super(envParser, endpoint);
+  }
+}