@geekmidas/constructs 0.3.1 → 0.5.0

package/src/endpoints/AmazonApiGatewayV1EndpointAdaptor.ts

@@ -1,101 +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 { Logger } from '@geekmidas/logger';
 import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import type { HttpMethod } from '../types';
 import {
-  AmazonApiGatewayEndpoint,
-  type AmazonApiGatewayV1EndpointHandler,
-  type GetInputResponse,
-  type LoggerContext,
+	AmazonApiGatewayEndpoint,
+	type AmazonApiGatewayEndpointOptions,
+	type AmazonApiGatewayV1EndpointHandler,
+	type GetInputResponse,
+	type LoggerContext,
 } from './AmazonApiGatewayEndpointAdaptor';
+import type { Endpoint, EndpointSchemas } from './Endpoint';
 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,
+	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
+	AmazonApiGatewayV1EndpointHandler,
+	APIGatewayProxyEvent,
+	TRoute,
+	TMethod,
+	TInput,
+	TOutSchema,
+	TServices,
+	TLogger,
+	TSession,
+	TEventPublisher
 > {
-  override getInput(e: APIGatewayProxyEvent): GetInputResponse {
-    // For arrays, AWS API Gateway V1 provides multiValueQueryStringParameters
-    const multiValueParams = e.multiValueQueryStringParameters || {};
-    const singleValueParams = e.queryStringParameters || {};
+	override 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[]> = {};
+		// 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;
-      }
-    }
+		// 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;
-      }
-    }
+		// 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 || {},
-    };
-  }
-  override 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 override envParser: EnvironmentParser<{}>,
-    protected override readonly endpoint: Endpoint<
-      TRoute,
-      TMethod,
-      TInput,
-      TOutSchema,
-      TServices,
-      TLogger,
-      TSession,
-      TEventPublisher
-    >,
-  ) {
-    super(envParser, endpoint);
-  }
+		return {
+			body: e.body ? JSON.parse(e.body) : undefined,
+			query: parseQueryParams(mergedParams),
+			params: e.pathParameters || {},
+		};
+	}
+	override 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 override envParser: EnvironmentParser<{}>,
+		protected override readonly endpoint: Endpoint<
+			TRoute,
+			TMethod,
+			TInput,
+			TOutSchema,
+			TServices,
+			TLogger,
+			TSession,
+			TEventPublisher
+		>,
+		options: AmazonApiGatewayEndpointOptions = {},
+	) {
+		super(envParser, endpoint, options);
+	}
 }

package/src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts

@@ -1,95 +1,99 @@
-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 { Logger } from '@geekmidas/logger';
 import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { APIGatewayProxyEventV2, Context } from 'aws-lambda';
+import type { HttpMethod } from '../types';
 import {
-  AmazonApiGatewayEndpoint,
-  type AmazonApiGatewayV2EndpointHandler,
-  type GetInputResponse,
-  type LoggerContext,
+	AmazonApiGatewayEndpoint,
+	type AmazonApiGatewayEndpointOptions,
+	type AmazonApiGatewayV2EndpointHandler,
+	type GetInputResponse,
+	type LoggerContext,
 } from './AmazonApiGatewayEndpointAdaptor';
+import type { Endpoint, EndpointSchemas } from './Endpoint';
 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,
+	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
+	AmazonApiGatewayV2EndpointHandler,
+	APIGatewayProxyEventV2,
+	TRoute,
+	TMethod,
+	TInput,
+	TOutSchema,
+	TServices,
+	TLogger,
+	TSession,
+	TEventPublisher
 > {
-  override getInput(e: APIGatewayProxyEventV2): GetInputResponse {
-    // API Gateway V2 handles arrays as comma-separated values
-    const queryParams = e.queryStringParameters || {};
-    const processedParams: Record<string, string | string[]> = {};
+	override 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;
-        }
-      }
-    }
+		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 || {},
-    };
-  }
-  override 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 override envParser: EnvironmentParser<{}>,
-    protected override readonly endpoint: Endpoint<
-      TRoute,
-      TMethod,
-      TInput,
-      TOutSchema,
-      TServices,
-      TLogger,
-      TSession,
-      TEventPublisher
-    >,
-  ) {
-    super(envParser, endpoint);
-  }
+		return {
+			body: e.body ? JSON.parse(e.body) : undefined,
+			query: parseQueryParams(processedParams),
+			params: e.pathParameters || {},
+		};
+	}
+	override 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 override envParser: EnvironmentParser<{}>,
+		protected override readonly endpoint: Endpoint<
+			TRoute,
+			TMethod,
+			TInput,
+			TOutSchema,
+			TServices,
+			TLogger,
+			TSession,
+			TEventPublisher
+		>,
+		options: AmazonApiGatewayEndpointOptions = {},
+	) {
+		super(envParser, endpoint, options);
+	}
 }
+
+// Re-export options type for convenience
+export type { AmazonApiGatewayEndpointOptions };

package/src/endpoints/Authorizer.ts

@@ -3,41 +3,41 @@
  * @see https://spec.openapis.org/oas/v3.1.0#security-scheme-object
  */
 export interface SecurityScheme {
-  /** The type of the security scheme */
-  type: 'apiKey' | 'http' | 'mutualTLS' | 'oauth2' | 'openIdConnect';
-  /** A description for security scheme */
-  description?: string;
-  /** Required for apiKey. The name of the header, query or cookie parameter */
-  name?: string;
-  /** Required for apiKey. The location of the API key */
-  in?: 'query' | 'header' | 'cookie';
-  /** Required for http. The name of the HTTP Authorization scheme (e.g., 'bearer') */
-  scheme?: string;
-  /** Optional for http bearer. A hint to the format of the bearer token */
-  bearerFormat?: string;
-  /** Required for oauth2. An object containing configuration for the flow types */
-  flows?: OAuthFlows;
-  /** Required for openIdConnect. The URL to discover OAuth2 configuration */
-  openIdConnectUrl?: string;
-  /** Vendor extensions (e.g., x-amazon-apigateway-authtype) */
-  [key: `x-${string}`]: unknown;
+	/** The type of the security scheme */
+	type: 'apiKey' | 'http' | 'mutualTLS' | 'oauth2' | 'openIdConnect';
+	/** A description for security scheme */
+	description?: string;
+	/** Required for apiKey. The name of the header, query or cookie parameter */
+	name?: string;
+	/** Required for apiKey. The location of the API key */
+	in?: 'query' | 'header' | 'cookie';
+	/** Required for http. The name of the HTTP Authorization scheme (e.g., 'bearer') */
+	scheme?: string;
+	/** Optional for http bearer. A hint to the format of the bearer token */
+	bearerFormat?: string;
+	/** Required for oauth2. An object containing configuration for the flow types */
+	flows?: OAuthFlows;
+	/** Required for openIdConnect. The URL to discover OAuth2 configuration */
+	openIdConnectUrl?: string;
+	/** Vendor extensions (e.g., x-amazon-apigateway-authtype) */
+	[key: `x-${string}`]: unknown;
 }
 
 /**
  * OAuth2 flow configuration
  */
 export interface OAuthFlows {
-  implicit?: OAuthFlow;
-  password?: OAuthFlow;
-  clientCredentials?: OAuthFlow;
-  authorizationCode?: OAuthFlow;
+	implicit?: OAuthFlow;
+	password?: OAuthFlow;
+	clientCredentials?: OAuthFlow;
+	authorizationCode?: OAuthFlow;
 }
 
 export interface OAuthFlow {
-  authorizationUrl?: string;
-  tokenUrl?: string;
-  refreshUrl?: string;
-  scopes: Record<string, string>;
+	authorizationUrl?: string;
+	tokenUrl?: string;
+	refreshUrl?: string;
+	scopes: Record<string, string>;
 }
 
 /**
@@ -45,40 +45,40 @@ export interface OAuthFlow {
  * Users can use these without defining them via .securitySchemes().
  */
 export const BUILT_IN_SECURITY_SCHEMES = {
-  jwt: {
-    type: 'http',
-    scheme: 'bearer',
-    bearerFormat: 'JWT',
-    description: 'JWT Bearer token authentication',
-  },
-  bearer: {
-    type: 'http',
-    scheme: 'bearer',
-    description: 'Bearer token authentication',
-  },
-  apiKey: {
-    type: 'apiKey',
-    in: 'header',
-    name: 'X-API-Key',
-    description: 'API key authentication via header',
-  },
-  oauth2: {
-    type: 'oauth2',
-    flows: {},
-    description: 'OAuth 2.0 authentication',
-  },
-  oidc: {
-    type: 'openIdConnect',
-    openIdConnectUrl: '',
-    description: 'OpenID Connect authentication',
-  },
-  iam: {
-    type: 'apiKey',
-    in: 'header',
-    name: 'Authorization',
-    description: 'AWS IAM Signature Version 4 authentication',
-    'x-amazon-apigateway-authtype': 'awsSigv4',
-  },
+	jwt: {
+		type: 'http',
+		scheme: 'bearer',
+		bearerFormat: 'JWT',
+		description: 'JWT Bearer token authentication',
+	},
+	bearer: {
+		type: 'http',
+		scheme: 'bearer',
+		description: 'Bearer token authentication',
+	},
+	apiKey: {
+		type: 'apiKey',
+		in: 'header',
+		name: 'X-API-Key',
+		description: 'API key authentication via header',
+	},
+	oauth2: {
+		type: 'oauth2',
+		flows: {},
+		description: 'OAuth 2.0 authentication',
+	},
+	oidc: {
+		type: 'openIdConnect',
+		openIdConnectUrl: '',
+		description: 'OpenID Connect authentication',
+	},
+	iam: {
+		type: 'apiKey',
+		in: 'header',
+		name: 'Authorization',
+		description: 'AWS IAM Signature Version 4 authentication',
+		'x-amazon-apigateway-authtype': 'awsSigv4',
+	},
 } as const satisfies Record<string, SecurityScheme>;
 
 /** Names of built-in security schemes */
@@ -88,65 +88,65 @@ export type BuiltInSecuritySchemeId = keyof typeof BUILT_IN_SECURITY_SCHEMES;
  * Represents an authorizer configuration for endpoints
  */
 export interface Authorizer {
-  /**
-   * Unique identifier for the authorizer
-   */
-  name: string;
-  /**
-   * The OpenAPI security scheme definition for this authorizer
-   */
-  securityScheme?: SecurityScheme;
-  /**
-   * Type of authorizer (e.g., 'iam', 'jwt', 'custom')
-   * @deprecated Use securityScheme.type instead
-   */
-  type?: string;
-  /**
-   * Description of what this authorizer does
-   * @deprecated Use securityScheme.description instead
-   */
-  description?: string;
-  /**
-   * Additional metadata specific to the authorizer type
-   * @deprecated Use securityScheme with x-* extensions instead
-   */
-  metadata?: Record<string, unknown>;
+	/**
+	 * Unique identifier for the authorizer
+	 */
+	name: string;
+	/**
+	 * The OpenAPI security scheme definition for this authorizer
+	 */
+	securityScheme?: SecurityScheme;
+	/**
+	 * Type of authorizer (e.g., 'iam', 'jwt', 'custom')
+	 * @deprecated Use securityScheme.type instead
+	 */
+	type?: string;
+	/**
+	 * Description of what this authorizer does
+	 * @deprecated Use securityScheme.description instead
+	 */
+	description?: string;
+	/**
+	 * Additional metadata specific to the authorizer type
+	 * @deprecated Use securityScheme with x-* extensions instead
+	 */
+	metadata?: Record<string, unknown>;
 }
 
 /**
  * Helper to create an authorizer configuration
  */
 export function createAuthorizer(
-  name: string,
-  options?: Omit<Authorizer, 'name'>,
+	name: string,
+	options?: Omit<Authorizer, 'name'>,
 ): Authorizer {
-  return {
-    name,
-    ...options,
-  };
+	return {
+		name,
+		...options,
+	};
 }
 
 /**
  * Check if a name is a built-in security scheme
  */
 export function isBuiltInSecurityScheme(
-  name: string,
+	name: string,
 ): name is BuiltInSecuritySchemeId {
-  return name in BUILT_IN_SECURITY_SCHEMES;
+	return name in BUILT_IN_SECURITY_SCHEMES;
 }
 
 /**
  * Get a security scheme by name (built-in or custom)
  */
 export function getSecurityScheme(
-  name: string,
-  customSchemes?: Record<string, SecurityScheme>,
+	name: string,
+	customSchemes?: Record<string, SecurityScheme>,
 ): SecurityScheme | undefined {
-  if (customSchemes && name in customSchemes) {
-    return customSchemes[name];
-  }
-  if (isBuiltInSecurityScheme(name)) {
-    return BUILT_IN_SECURITY_SCHEMES[name];
-  }
-  return undefined;
+	if (customSchemes && name in customSchemes) {
+		return customSchemes[name];
+	}
+	if (isBuiltInSecurityScheme(name)) {
+		return BUILT_IN_SECURITY_SCHEMES[name];
+	}
+	return undefined;
 }