@geekmidas/constructs 3.0.6 → 3.0.8

package/dist/adaptors/aws.cjs

@@ -1,21 +1,737 @@
-require('../Construct-BXG8cFSm.cjs');
-require('../publisher-lFQleddL.cjs');
-require('../BaseFunctionBuilder-DXf6HK-N.cjs');
-require('../Function-DgQ_no6B.cjs');
-require('../FunctionBuilder-C_xG9As7.cjs');
-require('../functions-rOD3pXQd.cjs');
-require('../Endpoint-BcxvF4F3.cjs');
-require('../processAudits-CzHkPokQ.cjs');
-require('../AmazonApiGatewayEndpointAdaptor-BIltcbAc.cjs');
-require('../parseQueryParams-B4RK1za3.cjs');
-const require_AmazonApiGatewayV1EndpointAdaptor = require('../AmazonApiGatewayV1EndpointAdaptor-DEETT6Wj.cjs');
-require('../lazyAccessors-BVEtB9lU.cjs');
-const require_AmazonApiGatewayV2EndpointAdaptor = require('../AmazonApiGatewayV2EndpointAdaptor-C2qO8FN6.cjs');
-require('../FunctionExecutionWrapper-KKHP6fDY.cjs');
-const require_AWSLambdaFunction = require('../AWSLambdaFunction-CPEAl5nZ.cjs');
-const require_AWSLambdaSubscriberAdaptor = require('../AWSLambdaSubscriberAdaptor-eZ3qoKvK.cjs');
-
-exports.AWSLambdaFunction = require_AWSLambdaFunction.AWSLambdaFunction;
-exports.AWSLambdaSubscriber = require_AWSLambdaSubscriberAdaptor.AWSLambdaSubscriber;
-exports.AmazonApiGatewayV1Endpoint = require_AmazonApiGatewayV1EndpointAdaptor.AmazonApiGatewayV1Endpoint;
-exports.AmazonApiGatewayV2Endpoint = require_AmazonApiGatewayV2EndpointAdaptor.AmazonApiGatewayV2Endpoint;
+const require_Construct = require('../Construct-B14miJ6P.cjs');
+const require_lazyAccessors = require('../lazyAccessors-DHvDeww0.cjs');
+const require_functions = require('../functions-DiaRAdfp.cjs');
+const require_processAudits = require('../processAudits-CUko08pi.cjs');
+const __geekmidas_db_rls = require_Construct.__toESM(require("@geekmidas/db/rls"));
+const __middy_core = require_Construct.__toESM(require("@middy/core"));
+const __geekmidas_errors = require_Construct.__toESM(require("@geekmidas/errors"));
+const __geekmidas_services = require_Construct.__toESM(require("@geekmidas/services"));
+const __geekmidas_audit = require_Construct.__toESM(require("@geekmidas/audit"));
+const qs = require_Construct.__toESM(require("qs"));
+const __geekmidas_audit_kysely = require_Construct.__toESM(require("@geekmidas/audit/kysely"));
+
+//#region src/endpoints/AmazonApiGatewayEndpointAdaptor.ts
+var import_lodash = require_Construct.__toESM(require_lazyAccessors.require_lodash(), 1);
+var AmazonApiGatewayEndpoint = class {
+	options;
+	constructor(envParser, endpoint, options = {}) {
+		this.envParser = envParser;
+		this.endpoint = endpoint;
+		this.options = options;
+	}
+	error() {
+		return { onError: (req) => {
+			(req.event.logger || this.endpoint.logger).error(req.error || {}, "Error processing request");
+			const wrappedError = (0, __geekmidas_errors.wrapError)(req.error);
+			req.response = {
+				statusCode: wrappedError.statusCode,
+				body: wrappedError.body
+			};
+		} };
+	}
+	/**
+	* Decodes the raw body from an API Gateway event.
+	* Uses Content-Type to decide parsing strategy (like Express/Fastify/Hono):
+	* - `application/json` (or missing) → JSON.parse the decoded string
+	* - Anything else → return decoded string as-is, let the schema handle it
+	*
+	* Defaults to JSON when no Content-Type is provided for backwards compatibility.
+	*/
+	static decodeBody(body, isBase64Encoded, contentType) {
+		if (!body) return void 0;
+		const raw = isBase64Encoded ? Buffer.from(body, "base64").toString("utf-8") : body;
+		const isJson = !contentType || contentType.toLowerCase().includes("application/json");
+		if (isJson) return JSON.parse(raw);
+		return raw;
+	}
+	getCookies(e) {
+		const headers = e.headers;
+		return require_lazyAccessors.Endpoint.createCookies(headers?.cookie);
+	}
+	input() {
+		return { before: async (req) => {
+			try {
+				const { body, query, params } = this.getInput(req.event);
+				const headers = req.event.headers;
+				const header = require_lazyAccessors.Endpoint.createHeaders(headers);
+				const cookie = this.getCookies(req.event);
+				(0, import_lodash.default)(req.event, "body", await this.endpoint.parseInput(body, "body"));
+				(0, import_lodash.default)(req.event, "query", await this.endpoint.parseInput(query, "query"));
+				(0, import_lodash.default)(req.event, "params", await this.endpoint.parseInput(params, "params"));
+				(0, import_lodash.default)(req.event, "header", header);
+				(0, import_lodash.default)(req.event, "cookie", cookie);
+			} catch (error) {
+				if (error && typeof error === "object" && Array.isArray(error)) throw new __geekmidas_errors.UnprocessableEntityError("Validation failed", error);
+				throw error;
+			}
+		} };
+	}
+	logger() {
+		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)
+			});
+		} };
+	}
+	services() {
+		return { before: async (req) => {
+			const _logger = req.event.logger;
+			const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+			const services = await serviceDiscovery.register(this.endpoint.services);
+			req.event.services = services;
+		} };
+	}
+	authorize() {
+		return { before: async (req) => {
+			const logger = req.event.logger;
+			const services = req.event.services;
+			const header = req.event.header;
+			const cookie = req.event.cookie;
+			const session = req.event.session;
+			const isAuthorized = await this.endpoint.authorize({
+				header,
+				cookie,
+				services,
+				logger,
+				session,
+				...req.event.db !== void 0 && { db: req.event.db },
+				body: req.event.body,
+				query: req.event.query,
+				params: req.event.params
+			});
+			if (!isAuthorized) {
+				logger.warn("Unauthorized access attempt");
+				throw new __geekmidas_errors.UnauthorizedError("Unauthorized access to the endpoint", "You do not have permission to access this resource.");
+			}
+		} };
+	}
+	database() {
+		return { before: async (req) => {
+			if (!this.endpoint.databaseService) return;
+			const _logger = req.event.logger;
+			const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+			const db = await serviceDiscovery.register([this.endpoint.databaseService]).then((s) => s[this.endpoint.databaseService?.serviceName]);
+			req.event.db = db;
+		} };
+	}
+	session() {
+		return { before: async (req) => {
+			const logger = req.event.logger;
+			const services = req.event.services;
+			const db = req.event.db;
+			req.event.session = await this.endpoint.getSession({
+				logger,
+				services,
+				header: req.event.header,
+				cookie: req.event.cookie,
+				...db !== void 0 && { db }
+			});
+		} };
+	}
+	events() {
+		return { after: async (req) => {
+			const event = req.event;
+			const response = event.__response;
+			const statusCode = req.response?.statusCode ?? this.endpoint.status;
+			if (require_lazyAccessors.Endpoint.isSuccessStatus(statusCode)) {
+				const logger = event.logger;
+				const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+				await require_lazyAccessors.publishConstructEvents(this.endpoint, response, serviceDiscovery, logger);
+			}
+		} };
+	}
+	async _handler(event) {
+		const input = this.endpoint.refineInput(event);
+		const logger = event.logger;
+		const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+		const auditContext = await require_processAudits.createAuditContext(this.endpoint, serviceDiscovery, logger, {
+			session: event.session,
+			header: event.header,
+			cookie: event.cookie,
+			services: event.services
+		});
+		const audits = this.endpoint.audits;
+		if (!auditContext && audits?.length) logger.warn("No auditor storage service available");
+		const rawDb = event.db;
+		const rlsActive = this.endpoint.rlsConfig && !this.endpoint.rlsBypass && rawDb !== void 0;
+		const rlsContext = rlsActive ? await this.endpoint.rlsConfig?.extractor({
+			services: event.services,
+			session: event.session,
+			header: event.header,
+			cookie: event.cookie,
+			logger
+		}) : void 0;
+		const result = await require_processAudits.executeWithAuditTransaction(auditContext, async (auditor) => {
+			const sameDatabase = auditContext?.storage?.databaseServiceName && auditContext.storage.databaseServiceName === this.endpoint.databaseService?.serviceName;
+			const baseDb = sameDatabase ? auditor?.getTransaction?.() ?? rawDb : rawDb;
+			const executeHandler = async (db) => {
+				const responseBuilder = new require_lazyAccessors.ResponseBuilder();
+				const response = await this.endpoint.handler({
+					header: event.header,
+					cookie: event.cookie,
+					logger: event.logger,
+					services: event.services,
+					session: event.session,
+					auditor,
+					db,
+					...input
+				}, responseBuilder);
+				let data = response;
+				let metadata$1 = responseBuilder.getMetadata();
+				if (require_lazyAccessors.Endpoint.hasMetadata(response)) {
+					data = response.data;
+					metadata$1 = response.metadata;
+				}
+				const output$1 = this.endpoint.outputSchema ? await this.endpoint.parseOutput(data) : void 0;
+				return {
+					output: output$1,
+					metadata: metadata$1,
+					responseBuilder
+				};
+			};
+			if (rlsActive && rlsContext && baseDb) return (0, __geekmidas_db_rls.withRlsContext)(baseDb, rlsContext, async (trx) => executeHandler(trx), { prefix: this.endpoint.rlsConfig?.prefix });
+			return executeHandler(baseDb);
+		}, async (result$1, auditor) => {
+			if (!audits?.length) return;
+			for (const audit of audits) {
+				if (audit.when && !audit.when(result$1.output)) continue;
+				const payload = audit.payload(result$1.output);
+				const entityId = audit.entityId?.(result$1.output);
+				auditor.audit(audit.type, payload, {
+					table: audit.table,
+					entityId
+				});
+			}
+		}, { db: rawDb });
+		const { output, metadata } = result;
+		const body = output !== void 0 ? JSON.stringify(output) : void 0;
+		event.__response = output;
+		const lambdaResponse = {
+			statusCode: metadata.status ?? this.endpoint.status,
+			body
+		};
+		if (metadata.headers && Object.keys(metadata.headers).length > 0) lambdaResponse.headers = { ...metadata.headers };
+		if (metadata.cookies && metadata.cookies.size > 0) {
+			const setCookieHeaders = [];
+			for (const [name, { value, options }] of metadata.cookies) setCookieHeaders.push(require_lazyAccessors.Endpoint.formatCookieHeader(name, value, options));
+			if (setCookieHeaders.length > 0) lambdaResponse.multiValueHeaders = {
+				...lambdaResponse.multiValueHeaders,
+				"Set-Cookie": setCookieHeaders
+			};
+		}
+		return lambdaResponse;
+	}
+	/**
+	* Convert Telemetry interface to Middy middleware
+	*/
+	telemetry() {
+		if (!this.options.telemetry) return null;
+		const telemetry = this.options.telemetry;
+		let ctx;
+		return {
+			before: (request) => {
+				ctx = telemetry.onRequestStart({
+					event: request.event,
+					context: request.context
+				});
+			},
+			after: (request) => {
+				if (ctx) telemetry.onRequestEnd(ctx, {
+					statusCode: request.response?.statusCode ?? 200,
+					body: request.response?.body,
+					headers: request.response?.headers
+				});
+			},
+			onError: (request) => {
+				if (ctx && request.error) telemetry.onRequestError(ctx, request.error instanceof Error ? request.error : new Error(String(request.error)));
+			}
+		};
+	}
+	get handler() {
+		const handler = this._handler.bind(this);
+		let chain = (0, __middy_core.default)(handler).use(this.logger()).use(this.error()).use(this.services()).use(this.input()).use(this.database()).use(this.session()).use(this.authorize()).use(this.events());
+		const telemetryMiddleware = this.telemetry();
+		if (telemetryMiddleware) chain = chain.use(telemetryMiddleware);
+		if (this.options.telescope?.middleware) chain = chain.use(this.options.telescope.middleware);
+		const wrappedHandler = async (event, context) => {
+			const startTime = Date.now();
+			const requestId = context.awsRequestId;
+			const logger = this.endpoint.logger.child({ requestId });
+			return (0, __geekmidas_services.runWithRequestContext)({
+				logger,
+				requestId,
+				startTime
+			}, () => chain(event, context));
+		};
+		return wrappedHandler;
+	}
+};
+
+//#endregion
+//#region src/endpoints/parseQueryParams.ts
+/**
+* Parse query parameters from a flat object into a nested structure
+* Uses qs bracket notation for standard interoperability
+*
+* @example
+* parseQueryParams({ 'tags[]': ['a', 'b'], 'filter[name]': 'john' })
+* // Returns: { tags: ['a', 'b'], filter: { name: 'john' } }
+*/
+function parseQueryParams(queryParams) {
+	if (!queryParams) return {};
+	const parts = [];
+	for (const [key, value] of Object.entries(queryParams)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+		else parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+	}
+	return qs.default.parse(parts.join("&"));
+}
+
+//#endregion
+//#region src/endpoints/AmazonApiGatewayV1EndpointAdaptor.ts
+var AmazonApiGatewayV1Endpoint = class extends AmazonApiGatewayEndpoint {
+	getInput(e) {
+		const multiValueParams = e.multiValueQueryStringParameters || {};
+		const singleValueParams = e.queryStringParameters || {};
+		const mergedParams = {};
+		for (const [key, value] of Object.entries(singleValueParams)) if (value !== void 0) mergedParams[key] = value;
+		for (const [key, values] of Object.entries(multiValueParams)) if (values && values.length > 1) mergedParams[key] = values;
+		return {
+			body: AmazonApiGatewayEndpoint.decodeBody(e.body, e.isBase64Encoded, e.headers?.["Content-Type"] ?? e.headers?.["content-type"]),
+			query: parseQueryParams(mergedParams),
+			params: e.pathParameters || {}
+		};
+	}
+	getLoggerContext(data, context) {
+		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 || void 0,
+				path: data.requestContext.path
+			}
+		};
+	}
+	constructor(envParser, endpoint, options = {}) {
+		super(envParser, endpoint, options);
+		this.envParser = envParser;
+		this.endpoint = endpoint;
+	}
+};
+
+//#endregion
+//#region src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts
+var AmazonApiGatewayV2Endpoint = class extends AmazonApiGatewayEndpoint {
+	getCookies(e) {
+		return require_lazyAccessors.createApiGatewayCookies(e.cookies, e.headers?.cookie);
+	}
+	getInput(e) {
+		const raw = AmazonApiGatewayEndpoint.decodeBody(e.body, e.isBase64Encoded, e.headers?.["content-type"]);
+		return {
+			body: raw,
+			query: qs.default.parse(e.rawQueryString),
+			params: e.pathParameters || {}
+		};
+	}
+	getLoggerContext(event, context) {
+		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 || void 0,
+				path: event.requestContext.http.path
+			}
+		};
+	}
+	constructor(envParser, endpoint, options = {}) {
+		super(envParser, endpoint, options);
+		this.envParser = envParser;
+		this.endpoint = endpoint;
+	}
+};
+
+//#endregion
+//#region src/functions/FunctionExecutionWrapper.ts
+var FunctionExecutionWrapper = class {
+	constructor(envParser, fn) {
+		this.envParser = envParser;
+		this.fn = fn;
+	}
+	_logger;
+	get logger() {
+		return this._logger || this.fn.logger;
+	}
+	get serviceDiscovery() {
+		const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+		return serviceDiscovery;
+	}
+	getServices() {
+		return this.serviceDiscovery.register(this.fn.services);
+	}
+	async getDatabase() {
+		if (!this.fn.databaseService) return void 0;
+		const services = await this.serviceDiscovery.register([this.fn.databaseService]);
+		return services[this.fn.databaseService.serviceName];
+	}
+	/**
+	* Get the audit storage service if configured.
+	* Returns undefined if no auditor storage is configured.
+	*/
+	async getAuditStorage() {
+		if (!this.fn.auditorStorageService) return void 0;
+		const services = await this.serviceDiscovery.register([this.fn.auditorStorageService]);
+		return services[this.fn.auditorStorageService.serviceName];
+	}
+	/**
+	* Create an auditor instance for the function.
+	* Returns undefined if no auditor storage is configured.
+	*/
+	async createAuditor() {
+		const storage = await this.getAuditStorage();
+		if (!storage) return void 0;
+		return new __geekmidas_audit.DefaultAuditor({
+			actor: {
+				id: "system",
+				type: "system"
+			},
+			storage,
+			metadata: { function: this.fn.type }
+		});
+	}
+	/**
+	* Execute handler with audit transaction support.
+	* If the audit storage has a database (via getDatabase()), wraps execution
+	* in a transaction so audits are atomic with handler's database operations.
+	*
+	* @param handler - The handler function to execute (receives auditor and db)
+	* @returns The handler result
+	*/
+	async executeWithAudit(handler) {
+		const auditor = await this.createAuditor();
+		const storage = await this.getAuditStorage();
+		if (!auditor || !storage) {
+			const db$1 = await this.getDatabase();
+			return handler({ db: db$1 });
+		}
+		const storageDb = storage.getDatabase?.();
+		const databaseServiceName = this.fn.databaseService?.serviceName;
+		const auditDbServiceName = this.fn.auditorStorageService?.serviceName;
+		if (storageDb && databaseServiceName && auditDbServiceName) return (0, __geekmidas_audit_kysely.withAuditableTransaction)(storageDb, auditor, async (trx) => {
+			const response$1 = await handler({
+				auditor,
+				db: trx
+			});
+			return response$1;
+		});
+		const db = await this.getDatabase();
+		const response = await handler({
+			auditor,
+			db
+		});
+		await auditor.flush();
+		return response;
+	}
+	async getFunctionInput(event) {
+		const parsedInput = await require_functions.FunctionBuilder.parseComposableStandardSchema(event, this.fn.input);
+		return parsedInput;
+	}
+	async publishEvents(response) {
+		await require_lazyAccessors.publishEvents(this.logger, this.serviceDiscovery, this.fn.events, response, this.fn.publisherService);
+	}
+	async parseComposableStandardSchema(data, schema) {
+		return require_functions.FunctionBuilder.parseComposableStandardSchema(data, schema);
+	}
+};
+
+//#endregion
+//#region src/functions/AWSLambdaFunction.ts
+var AWSLambdaFunction = class extends FunctionExecutionWrapper {
+	constructor(envParser, fn) {
+		super(envParser, fn);
+		this.fn = fn;
+	}
+	error() {
+		return { onError: (req) => {
+			const logger = req.event?.logger || this.fn.logger;
+			logger.error(req.error || {}, "Error processing function");
+			throw (0, __geekmidas_errors.wrapError)(req.error);
+		} };
+	}
+	baseInput() {
+		return { before: (_req) => {} };
+	}
+	input() {
+		return { before: async (req) => {
+			try {
+				if (this.fn.input) {
+					const parsedInput = await require_functions.FunctionBuilder.parseComposableStandardSchema(req.event, this.fn.input);
+					req.event.parsedInput = parsedInput;
+				} else req.event.parsedInput = req.event;
+			} catch (error) {
+				this.logger.error({
+					error,
+					event: req.event
+				}, "Failed to parse input");
+				throw error;
+			}
+		} };
+	}
+	loggerMiddleware() {
+		return { before: (req) => {
+			this._logger = this.fn.logger.child({
+				fn: {
+					name: req.context.functionName,
+					version: req.context.functionVersion,
+					memory: req.context.memoryLimitInMB
+				},
+				req: { id: req.context.awsRequestId }
+			});
+			req.event.logger = this._logger;
+		} };
+	}
+	services() {
+		return { before: async (req) => {
+			req.event.services = await this.getServices();
+		} };
+	}
+	database() {
+		return { before: async (req) => {
+			req.event.db = await this.getDatabase();
+		} };
+	}
+	auditor() {
+		return {
+			before: async (req) => {
+				req.event.auditor = await this.createAuditor();
+			},
+			after: async (req) => {
+				if (req.event.auditor) {
+					const records = req.event.auditor.getRecords();
+					if (records.length > 0) {
+						this.logger.debug({ auditCount: records.length }, "Flushing function audits");
+						await req.event.auditor.flush();
+					}
+				}
+			}
+		};
+	}
+	events() {
+		return { after: async (req) => {
+			const response = req.response || void 0;
+			await this.publishEvents(response);
+		} };
+	}
+	async _handler(event) {
+		const result = await this.fn.fn({
+			input: event.parsedInput,
+			services: event.services,
+			logger: event.logger,
+			db: event.db,
+			auditor: event.auditor
+		});
+		const output = await this.fn.parseOutput(result);
+		return output;
+	}
+	get handler() {
+		const handler = this._handler.bind(this);
+		const chain = (0, __middy_core.default)(handler).use(this.loggerMiddleware()).use(this.baseInput()).use(this.error()).use(this.services()).use(this.database()).use(this.auditor()).use(this.input()).use(this.events());
+		const wrappedHandler = async (event, context) => {
+			const startTime = Date.now();
+			const requestId = context.awsRequestId;
+			const logger = this.fn.logger.child({ requestId });
+			return (0, __geekmidas_services.runWithRequestContext)({
+				logger,
+				requestId,
+				startTime
+			}, () => chain(event, context));
+		};
+		return wrappedHandler;
+	}
+};
+
+//#endregion
+//#region src/subscribers/AWSLambdaSubscriberAdaptor.ts
+var AWSLambdaSubscriber = class {
+	_logger;
+	_services;
+	constructor(envParser, subscriber) {
+		this.envParser = envParser;
+		this.subscriber = subscriber;
+		this._logger = subscriber.logger;
+	}
+	get logger() {
+		return this._logger;
+	}
+	async getServices() {
+		if (this._services) return this._services;
+		const serviceDiscovery = __geekmidas_services.ServiceDiscovery.getInstance(this.envParser);
+		if (this.subscriber.services.length > 0) {
+			const registered = await serviceDiscovery.register(this.subscriber.services);
+			this._services = registered;
+		} else this._services = {};
+		return this._services;
+	}
+	error() {
+		return { onError: (req) => {
+			const logger = req.event?.logger || this.subscriber.logger;
+			logger.error(req.error || {}, "Error processing subscriber");
+			throw (0, __geekmidas_errors.wrapError)(req.error);
+		} };
+	}
+	loggerMiddleware() {
+		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 }
+			});
+			req.event.logger = this._logger;
+		} };
+	}
+	services() {
+		return { before: async (req) => {
+			req.event.services = await this.getServices();
+		} };
+	}
+	parseEvents() {
+		return { before: async (req) => {
+			const { logger,...e } = req.event;
+			const rawEvent = e;
+			logger.info({ rawEvent });
+			const events = [];
+			if ("Records" in rawEvent) {
+				if (this.isSQSEvent(rawEvent)) 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)) 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.events = events;
+		} };
+	}
+	isSQSEvent(event) {
+		const firstRecord = event.Records[0];
+		return "Records" in event && event.Records.length > 0 && firstRecord !== void 0 && "eventSource" in firstRecord && firstRecord.eventSource === "aws:sqs";
+	}
+	isSNSEvent(event) {
+		const firstRecord = event.Records[0];
+		return "Records" in event && event.Records.length > 0 && firstRecord !== void 0 && "EventSource" in firstRecord && firstRecord.EventSource === "aws:sns";
+	}
+	parseSNSRecord(record) {
+		const message = this.safeJsonParse(record.Sns.Message);
+		const messageType = record.Sns.MessageAttributes?.type?.Value;
+		if (message === null) return messageType ? {
+			type: messageType,
+			payload: record.Sns.Message
+		} : record.Sns.Message;
+		const resolvedType = messageType ?? message.type;
+		if (message.type) return message;
+		return resolvedType ? {
+			type: resolvedType,
+			payload: message
+		} : message;
+	}
+	parseSQSRecord(record) {
+		const body = this.safeJsonParse(record.body);
+		if (body === null) return record.body;
+		if (body.Type === "Notification" && body.Message) {
+			const snsMessage = this.safeJsonParse(body.Message);
+			const messageType = body.MessageAttributes?.type?.Value;
+			if (snsMessage === null) return messageType ? {
+				type: messageType,
+				payload: body.Message
+			} : body.Message;
+			if (snsMessage.type) return snsMessage;
+			const resolvedType = messageType ?? snsMessage.type;
+			return resolvedType ? {
+				type: resolvedType,
+				payload: snsMessage
+			} : snsMessage;
+		}
+		return body;
+	}
+	safeJsonParse(value) {
+		try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+	}
+	shouldIncludeEvent(event) {
+		if (typeof event !== "object" || !event?.type) return true;
+		if (!this.subscriber.subscribedEvents) return true;
+		return this.subscriber.subscribedEvents.includes(event.type);
+	}
+	async _handler(event) {
+		if (event.events.length === 0) {
+			this.logger.info("No subscribed events to process");
+			return { batchItemFailures: [] };
+		}
+		const result = await this.subscriber.handler({
+			events: event.events,
+			services: event.services,
+			logger: event.logger
+		});
+		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() {
+		const handler = this._handler.bind(this);
+		const chain = (0, __middy_core.default)(handler).use(this.loggerMiddleware()).use(this.parseEvents()).use(this.error()).use(this.services());
+		const wrappedHandler = async (event, context) => {
+			const startTime = Date.now();
+			const requestId = context.awsRequestId;
+			const logger = this.subscriber.logger.child({ requestId });
+			return (0, __geekmidas_services.runWithRequestContext)({
+				logger,
+				requestId,
+				startTime
+			}, () => chain(event, context));
+		};
+		return wrappedHandler;
+	}
+};
+
+//#endregion
+exports.AWSLambdaFunction = AWSLambdaFunction;
+exports.AWSLambdaSubscriber = AWSLambdaSubscriber;
+exports.AmazonApiGatewayV1Endpoint = AmazonApiGatewayV1Endpoint;
+exports.AmazonApiGatewayV2Endpoint = AmazonApiGatewayV2Endpoint;
+//# sourceMappingURL=aws.cjs.map