@geekmidas/constructs 10.0.0-alpha.11 → 10.0.0-alpha.111

package/dist/adaptors/aws.mjs

@@ -1,21 +1,23 @@
-import { __toESM } from "../Construct-BD5neF7w.mjs";
-import "../construct-interface-Z4CpS8tK.mjs";
-import { FunctionBuilder } from "../functions-14lpEFL4.mjs";
-import "../clone-DblgEZZa.mjs";
-import { Endpoint, ResponseBuilder, require_lodash } from "../Endpoint-DCQPMdUX.mjs";
-import { envParserFor } from "../surfaceEnv-C3Ktahea.mjs";
-import { createApiGatewayCookies, publishConstructEvents, publishEvents } from "../lazyAccessors-BoJN3SMd.mjs";
-import { createAuditContext, executeWithAuditTransaction } from "../processAudits-Dmts9H_b.mjs";
+import { o as __toESM } from "../Construct-CKUA-CTA.mjs";
+import { r as recordCarrier } from "../tracing-Bbj1uoFJ.mjs";
+import { a as publishEvents, i as publishConstructEvents, t as FunctionBuilder } from "../functions-CTI-hDem.mjs";
+import { o as require_lodash_set, r as ResponseBuilder, t as Endpoint } from "../Endpoint-gPXhHKhJ.mjs";
+import { n as envParserFor } from "../surfaceEnv-wMT5QzgZ.mjs";
+import { a as createApiGatewayCookies, i as readRequestBody } from "../readRequestBody-BTIl3k-D.mjs";
+import { n as subscribedEvents, r as subscriberContext, t as runSubscriber } from "../runSubscriber-BHvJ8POr.mjs";
+import { i as executeWithAuditTransaction, n as enforceRateLimit, r as createAuditContext, t as requestLogger } from "../requestLogger-pA4gi3E1.mjs";
+import { consumeBatchTraced } from "@geekmidas/events";
+import { ServiceDiscovery, currentRequestContext, runWithRequestContext } from "@geekmidas/services";
 import { ForbiddenError, UnprocessableEntityError, wrapError } from "@geekmidas/errors";
-import { ServiceDiscovery, runWithRequestContext } from "@geekmidas/services";
+import qs from "qs";
 import middy from "@middy/core";
 import { DefaultAuditor } from "@geekmidas/audit";
 import { withAuditableTransaction } from "@geekmidas/audit/kysely";
 import { withRlsContext } from "@geekmidas/db/rls";
-import qs from "qs";
-
 //#region src/functions/FunctionExecutionWrapper.ts
 var FunctionExecutionWrapper = class {
+	envParser;
+	fn;
 	constructor(envParser, fn) {
 		this.envParser = envParser;
 		this.fn = fn;
@@ -25,25 +27,22 @@ var FunctionExecutionWrapper = class {
 		return this._logger || this.fn.logger;
 	}
 	get serviceDiscovery() {
-		const serviceDiscovery = ServiceDiscovery.getInstance(this.envParser);
-		return serviceDiscovery;
+		return ServiceDiscovery.getInstance(this.envParser);
 	}
 	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];
+		if (!this.fn.databaseService) return;
+		return (await this.serviceDiscovery.register([this.fn.databaseService]))[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];
+		if (!this.fn.auditorStorageService) return;
+		return (await this.serviceDiscovery.register([this.fn.auditorStorageService]))[this.fn.auditorStorageService.serviceName];
 	}
 	/**
 	* Create an auditor instance for the function.
@@ -51,7 +50,7 @@ var FunctionExecutionWrapper = class {
 	*/
 	async createAuditor() {
 		const storage = await this.getAuditStorage();
-		if (!storage) return void 0;
+		if (!storage) return;
 		return new DefaultAuditor({
 			actor: {
 				id: "system",
@@ -72,51 +71,44 @@ var FunctionExecutionWrapper = class {
 	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 });
-		}
+		if (!auditor || !storage) return handler({ db: await this.getDatabase() });
 		const storageDb = storage.getDatabase?.();
 		const databaseServiceName = this.fn.databaseService?.serviceName;
 		const auditDbServiceName = this.fn.auditorStorageService?.serviceName;
 		if (storageDb && databaseServiceName && auditDbServiceName) return withAuditableTransaction(storageDb, auditor, async (trx) => {
-			const response$1 = await handler({
+			return await handler({
 				auditor,
 				db: trx
 			});
-			return response$1;
 		});
-		const db = await this.getDatabase();
 		const response = await handler({
 			auditor,
-			db
+			db: await this.getDatabase()
 		});
 		await auditor.flush();
 		return response;
 	}
 	async getFunctionInput(event) {
-		const parsedInput = await FunctionBuilder.parseComposableStandardSchema(event, this.fn.input);
-		return parsedInput;
+		return await FunctionBuilder.parseComposableStandardSchema(event, this.fn.input);
 	}
 	async publishEvents(response) {
-		await publishEvents(this.logger, this.serviceDiscovery, this.fn.events, response, this.fn.publisherService);
+		await publishEvents(this.logger, this.serviceDiscovery, this.fn.events, response);
 	}
 	async parseComposableStandardSchema(data, schema) {
 		return FunctionBuilder.parseComposableStandardSchema(data, schema);
 	}
 };
-
 //#endregion
 //#region src/functions/AWSLambdaFunction.ts
 var AWSLambdaFunction = class extends FunctionExecutionWrapper {
+	fn;
 	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");
+			(req.event?.logger || this.fn.logger).error(req.error || {}, "Error processing function");
 			throw wrapError(req.error);
 		} };
 	}
@@ -132,7 +124,7 @@ var AWSLambdaFunction = class extends FunctionExecutionWrapper {
 				} else req.event.parsedInput = req.event;
 			} catch (error) {
 				this.logger.error({
-					error,
+					err: error,
 					event: req.event
 				}, "Failed to parse input");
 				throw error;
@@ -192,8 +184,7 @@ var AWSLambdaFunction = class extends FunctionExecutionWrapper {
 			db: event.db,
 			auditor: event.auditor
 		});
-		const output = await this.fn.parseOutput(result);
-		return output;
+		return await this.fn.parseOutput(result);
 	}
 	get handler() {
 		const handler = this._handler.bind(this);
@@ -205,13 +196,13 @@ var AWSLambdaFunction = class extends FunctionExecutionWrapper {
 			return runWithRequestContext({
 				logger,
 				requestId,
-				startTime
+				startTime,
+				operation: context.functionName
 			}, () => chain(event, context));
 		};
 		return wrappedHandler;
 	}
 };
-
 //#endregion
 //#region src/crons/AWSScheduledFunction.ts
 /**
@@ -245,11 +236,11 @@ var AWSScheduledFunction = class extends AWSLambdaFunction {
 		super(envParser, cron);
 	}
 };
-
 //#endregion
 //#region src/endpoints/AmazonApiGatewayEndpointAdaptor.ts
-var import_lodash = __toESM(require_lodash(), 1);
-var AmazonApiGatewayEndpoint = class {
+var import_lodash_set = /* @__PURE__ */ __toESM(require_lodash_set(), 1);
+var AmazonApiGatewayEndpoint = class AmazonApiGatewayEndpoint {
+	endpoint;
 	options;
 	/**
 	* The parser this adaptor discovers services with.
@@ -272,24 +263,36 @@ var AmazonApiGatewayEndpoint = class {
 			const wrappedError = wrapError(req.error);
 			req.response = {
 				statusCode: wrappedError.statusCode,
-				body: wrappedError.body
+				body: wrappedError.body,
+				...wrappedError.headers ? { headers: { ...wrappedError.headers } } : {}
 			};
 		} };
 	}
 	/**
-	* 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
+	* Decodes the raw body from an API Gateway event — base64 when API
+	* Gateway says so — and reads it by its Content-Type, as every adaptor
+	* does (see {@link readRequestBody}): JSON, an HTML form's fields, or text.
 	*
-	* Defaults to JSON when no Content-Type is provided for backwards compatibility.
+	* A body with no Content-Type is read as JSON, as it always has been here.
 	*/
-	static decodeBody(body, isBase64Encoded, contentType) {
+	static async 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;
+		const bytes = Buffer.from(body, isBase64Encoded ? "base64" : "utf-8");
+		const request = new Request("http://api-gateway.invalid/", {
+			method: "POST",
+			headers: contentType ? { "content-type": contentType } : {},
+			body: bytes
+		});
+		return readRequestBody(request, contentType, { untyped: "json" });
+	}
+	/**
+	* The event's body, read only for an endpoint with a `.body()` schema —
+	* one without is handed no body, and is not refused a content type it
+	* never reads.
+	*/
+	readBody(body, isBase64Encoded, contentType) {
+		if (!this.endpoint.input?.body) return Promise.resolve(void 0);
+		return AmazonApiGatewayEndpoint.decodeBody(body, isBase64Encoded, contentType);
 	}
 	getCookies(e) {
 		const headers = e.headers;
@@ -298,36 +301,38 @@ var AmazonApiGatewayEndpoint = class {
 	input() {
 		return { before: async (req) => {
 			try {
-				const { body, query, params } = this.getInput(req.event);
+				const { body, query, params } = await this.getInput(req.event);
 				const headers = req.event.headers;
 				const header = 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);
+				(0, import_lodash_set.default)(req.event, "body", await this.endpoint.parseInput(body, "body"));
+				(0, import_lodash_set.default)(req.event, "query", await this.endpoint.parseInput(query, "query"));
+				(0, import_lodash_set.default)(req.event, "params", await this.endpoint.parseInput(params, "params"));
+				(0, import_lodash_set.default)(req.event, "header", header);
+				(0, import_lodash_set.default)(req.event, "cookie", cookie);
 			} catch (error) {
 				if (error && typeof error === "object" && Array.isArray(error)) throw new UnprocessableEntityError("Validation failed", error);
 				throw error;
 			}
 		} };
 	}
+	/** This request's logger: see {@link requestLogger}. */
+	requestLogger(event, context) {
+		return requestLogger(this.endpoint, {
+			requestId: context.awsRequestId,
+			host: event.headers?.host,
+			...this.getLoggerContext(event, context)
+		});
+	}
 	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)
-			});
+			req.event.logger = currentRequestContext()?.logger ?? this.requestLogger(req.event, req.context);
 		} };
 	}
 	services() {
 		return { before: async (req) => {
-			const _logger = req.event.logger;
-			const serviceDiscovery = ServiceDiscovery.getInstance(this.envParser);
-			const services = await serviceDiscovery.register(this.endpoint.services);
+			req.event.logger;
+			const services = await ServiceDiscovery.getInstance(this.envParser).register(this.endpoint.services);
 			req.event.services = services;
 		} };
 	}
@@ -338,7 +343,7 @@ var AmazonApiGatewayEndpoint = class {
 			const header = req.event.header;
 			const cookie = req.event.cookie;
 			const session = req.event.session;
-			const isAuthorized = await this.endpoint.authorize({
+			if (!await this.endpoint.authorize({
 				header,
 				cookie,
 				services,
@@ -348,19 +353,39 @@ var AmazonApiGatewayEndpoint = class {
 				body: req.event.body,
 				query: req.event.query,
 				params: req.event.params
-			});
-			if (!isAuthorized) {
+			})) {
 				logger.warn("Forbidden access attempt");
 				throw new ForbiddenError("Forbidden access to the endpoint", "You do not have permission to access this resource.");
 			}
 		} };
 	}
+	/**
+	* The endpoint's `.rateLimit()`, after authorization as on every adaptor:
+	* over the limit it throws a 429, which `error()` answers with its
+	* headers; under it, the `X-RateLimit-*` headers go on the response.
+	*/
+	rateLimit() {
+		return { before: async (req) => {
+			if (!this.endpoint.rateLimit) return;
+			req.event.rateLimitHeaders = await enforceRateLimit(this.endpoint.rateLimit, {
+				header: req.event.header,
+				services: req.event.services,
+				logger: req.event.logger,
+				session: req.event.session,
+				path: this.requestPath(req.event),
+				method: this.endpoint.method
+			});
+		} };
+	}
+	/** The path the request was made to, as the limiter keys a client by. */
+	requestPath(event) {
+		return event.path ?? event.rawPath ?? this.endpoint.route;
+	}
 	database() {
 		return { before: async (req) => {
 			if (!this.endpoint.databaseService) return;
-			const _logger = req.event.logger;
-			const serviceDiscovery = ServiceDiscovery.getInstance(this.envParser);
-			const db = await serviceDiscovery.register([this.endpoint.databaseService]).then((s) => s[this.endpoint.databaseService?.serviceName]);
+			req.event.logger;
+			const db = await ServiceDiscovery.getInstance(this.envParser).register([this.endpoint.databaseService]).then((s) => s[this.endpoint.databaseService?.serviceName]);
 			req.event.db = db;
 		} };
 	}
@@ -376,6 +401,7 @@ var AmazonApiGatewayEndpoint = class {
 				cookie: req.event.cookie,
 				...db !== void 0 && { db }
 			});
+			req.event.logger = currentRequestContext()?.logger ?? req.event.logger;
 		} };
 	}
 	events() {
@@ -411,9 +437,8 @@ var AmazonApiGatewayEndpoint = class {
 			cookie: event.cookie,
 			logger
 		}) : void 0;
-		const result = await executeWithAuditTransaction(auditContext, async (auditor) => {
-			const sameDatabase = auditContext?.storage?.databaseServiceName && auditContext.storage.databaseServiceName === this.endpoint.databaseService?.serviceName;
-			const baseDb = sameDatabase ? auditor?.getTransaction?.() ?? rawDb : rawDb;
+		const { output, metadata } = await executeWithAuditTransaction(auditContext, async (auditor) => {
+			const baseDb = auditContext?.storage?.databaseServiceName && auditContext.storage.databaseServiceName === this.endpoint.databaseService?.serviceName ? auditor?.getTransaction?.() ?? rawDb : rawDb;
 			const executeHandler = async (db) => {
 				const responseBuilder = new ResponseBuilder();
 				const response = await this.endpoint.handler({
@@ -427,33 +452,33 @@ var AmazonApiGatewayEndpoint = class {
 					...input
 				}, responseBuilder);
 				let data = response;
-				let metadata$1 = responseBuilder.getMetadata();
+				let metadata = responseBuilder.getMetadata();
 				if (Endpoint.hasMetadata(response)) {
 					data = response.data;
-					metadata$1 = response.metadata;
+					metadata = response.metadata;
 				}
-				const output$1 = this.endpoint.outputSchema ? await this.endpoint.parseOutput(data) : void 0;
+				const redirect = Endpoint.isRedirectStatus(metadata.status ?? this.endpoint.status);
 				return {
-					output: output$1,
-					metadata: metadata$1,
-					responseBuilder
+					output: this.endpoint.outputSchema && !redirect ? await this.endpoint.parseOutput(data) : void 0,
+					metadata,
+					responseBuilder,
+					redirect
 				};
 			};
 			if (rlsActive && rlsContext && baseDb) return withRlsContext(baseDb, rlsContext, async (trx) => executeHandler(trx), { prefix: this.endpoint.rlsConfig?.prefix });
 			return executeHandler(baseDb);
-		}, async (result$1, auditor) => {
-			if (!audits?.length) return;
+		}, async (result, auditor) => {
+			if (!audits?.length || result.redirect) 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);
+				if (audit.when && !audit.when(result.output)) continue;
+				const payload = audit.payload(result.output);
+				const entityId = audit.entityId?.(result.output);
 				auditor.audit(audit.type, payload, {
 					table: audit.table,
 					entityId
 				});
 			}
 		}, { db: rawDb });
-		const { output, metadata } = result;
 		const isJsonResponse = this.endpoint.responseType === "application/json";
 		const body = output === void 0 ? void 0 : isJsonResponse ? JSON.stringify(output) : typeof output === "string" ? output : String(output);
 		event.__response = output;
@@ -462,8 +487,10 @@ var AmazonApiGatewayEndpoint = class {
 			body
 		};
 		const baseHeaders = isJsonResponse ? void 0 : { "content-type": this.endpoint.responseType };
-		if (baseHeaders || metadata.headers && Object.keys(metadata.headers).length > 0) lambdaResponse.headers = {
+		const rateLimitHeaders = event.rateLimitHeaders;
+		if (baseHeaders || rateLimitHeaders || metadata.headers && Object.keys(metadata.headers).length > 0) lambdaResponse.headers = {
 			...baseHeaders ?? {},
+			...rateLimitHeaders ?? {},
 			...metadata.headers ?? {}
 		};
 		if (metadata.cookies && metadata.cookies.size > 0) {
@@ -504,24 +531,25 @@ var AmazonApiGatewayEndpoint = class {
 	}
 	get handler() {
 		const handler = this._handler.bind(this);
-		let chain = middy(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());
+		let chain = middy(handler).use(this.logger()).use(this.error()).use(this.services()).use(this.input()).use(this.database()).use(this.session()).use(this.authorize()).use(this.rateLimit()).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 });
+			const logger = this.requestLogger(event, context);
+			const operation = `${this.endpoint.method} ${this.endpoint.route}`;
 			return runWithRequestContext({
 				logger,
 				requestId,
-				startTime
+				startTime,
+				operation
 			}, () => chain(event, context));
 		};
 		return wrappedHandler;
 	}
 };
-
 //#endregion
 //#region src/endpoints/parseQueryParams.ts
 /**
@@ -542,18 +570,18 @@ function parseQueryParams(queryParams) {
 	}
 	return qs.parse(parts.join("&"));
 }
-
 //#endregion
 //#region src/endpoints/AmazonApiGatewayV1EndpointAdaptor.ts
 var AmazonApiGatewayV1Endpoint = class extends AmazonApiGatewayEndpoint {
-	getInput(e) {
+	endpoint;
+	async 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"]),
+			body: await this.readBody(e.body, e.isBase64Encoded, e.headers?.["Content-Type"] ?? e.headers?.["content-type"]),
 			query: parseQueryParams(mergedParams),
 			params: e.pathParameters || {}
 		};
@@ -578,17 +606,16 @@ var AmazonApiGatewayV1Endpoint = class extends AmazonApiGatewayEndpoint {
 		this.endpoint = endpoint;
 	}
 };
-
 //#endregion
 //#region src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts
 var AmazonApiGatewayV2Endpoint = class extends AmazonApiGatewayEndpoint {
+	endpoint;
 	getCookies(e) {
 		return createApiGatewayCookies(e.cookies, e.headers?.cookie);
 	}
-	getInput(e) {
-		const raw = AmazonApiGatewayEndpoint.decodeBody(e.body, e.isBase64Encoded, e.headers?.["content-type"]);
+	async getInput(e) {
 		return {
-			body: raw,
+			body: await this.readBody(e.body, e.isBase64Encoded, e.headers?.["content-type"]),
 			query: qs.parse(e.rawQueryString),
 			params: e.pathParameters || {}
 		};
@@ -613,7 +640,6 @@ var AmazonApiGatewayV2Endpoint = class extends AmazonApiGatewayEndpoint {
 		this.endpoint = endpoint;
 	}
 };
-
 //#endregion
 //#region src/queue/AWSLambdaQueueAdaptor.ts
 /**
@@ -628,6 +654,8 @@ var AmazonApiGatewayV2Endpoint = class extends AmazonApiGatewayEndpoint {
 * retries only those records.
 */
 var AWSLambdaQueue = class {
+	envParser;
+	queue;
 	_services;
 	constructor(envParser, queue) {
 		this.envParser = envParser;
@@ -642,6 +670,12 @@ var AWSLambdaQueue = class {
 		this._services = this.queue.services.length > 0 ? await serviceDiscovery.register(this.queue.services) : {};
 		return this._services;
 	}
+	/** The queue's database, registered as functions register theirs. */
+	async getDatabase() {
+		const service = this.queue.databaseService;
+		if (!service) return void 0;
+		return (await ServiceDiscovery.getInstance(this.envParser).register([service]))[service.serviceName];
+	}
 	safeJsonParse(value) {
 		try {
 			return JSON.parse(value);
@@ -667,6 +701,7 @@ var AWSLambdaQueue = class {
 			req: { id: context.awsRequestId }
 		});
 		const services = await this.getServices();
+		const db = await this.getDatabase();
 		const schema = this.queue.messageSchema;
 		const batchItemFailures = [];
 		const messages = [];
@@ -684,7 +719,7 @@ var AWSLambdaQueue = class {
 			messages.push(validation.value);
 		} catch (error) {
 			logger.error({
-				error,
+				err: error,
 				messageId: record.messageId
 			}, "Failed to parse SQS record");
 			batchItemFailures.push({ itemIdentifier: record.messageId });
@@ -694,7 +729,8 @@ var AWSLambdaQueue = class {
 			await this.queue.handler({
 				messages,
 				services,
-				logger
+				logger,
+				db
 			});
 		} catch (error) {
 			logger.error(wrapError(error), "Queue handler failed; retrying batch");
@@ -704,24 +740,28 @@ var AWSLambdaQueue = class {
 	}
 	get handler() {
 		const handler = this._handler.bind(this);
-		return async (event, context) => {
+		return (async (event, context) => {
 			const startTime = Date.now();
 			const requestId = context.awsRequestId;
 			const logger = this.queue.logger.child({ requestId });
 			return runWithRequestContext({
 				logger,
 				requestId,
-				startTime
-			}, () => handler(event, context));
-		};
+				startTime,
+				operation: `queue ${this.queue.name}`
+			}, () => consumeBatchTraced({
+				system: "aws_sqs",
+				destination: this.queue.name
+			}, event.Records.map(recordCarrier), () => handler(event, context)));
+		});
 	}
 };
-
 //#endregion
 //#region src/subscribers/AWSLambdaSubscriberAdaptor.ts
 var AWSLambdaSubscriber = class {
+	envParser;
+	subscriber;
 	_logger;
-	_services;
 	constructor(envParser, subscriber) {
 		this.envParser = envParser;
 		this.subscriber = subscriber;
@@ -730,19 +770,9 @@ var AWSLambdaSubscriber = class {
 	get logger() {
 		return this._logger;
 	}
-	async getServices() {
-		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;
-		} 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");
+			(req.event?.logger || this.subscriber.logger).error(req.error || {}, "Error processing subscriber");
 			throw wrapError(req.error);
 		} };
 	}
@@ -761,110 +791,26 @@ var AWSLambdaSubscriber = class {
 	}
 	services() {
 		return { before: async (req) => {
-			req.event.services = await this.getServices();
+			const { services, db } = await subscriberContext(this.subscriber, this.envParser);
+			req.event.services = services;
+			req.event.db = db;
 		} };
 	}
 	parseEvents() {
 		return { before: async (req) => {
-			const { logger,...e } = req.event;
-			const rawEvent = e;
+			const { logger, ...rawEvent } = req.event;
 			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;
+			req.event.events = subscribedEvents(this.subscriber, rawEvent, this.logger);
 		} };
 	}
-	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
+		const { events, services, logger, db } = event;
+		return runSubscriber(this.subscriber, {
+			events,
+			services,
+			logger,
+			db
 		});
-		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);
@@ -873,16 +819,22 @@ var AWSLambdaSubscriber = class {
 			const startTime = Date.now();
 			const requestId = context.awsRequestId;
 			const logger = this.subscriber.logger.child({ requestId });
+			const operation = `subscriber ${this.subscriber.topicName ?? context.functionName}`;
+			const records = event?.Records ?? [];
 			return runWithRequestContext({
 				logger,
 				requestId,
-				startTime
-			}, () => chain(event, context));
+				startTime,
+				operation
+			}, () => consumeBatchTraced({
+				system: records[0]?.Sns ? "aws_sns" : "aws_sqs",
+				destination: this.subscriber.topicName ?? context.functionName
+			}, records.map(recordCarrier), () => chain(event, context)));
 		};
 		return wrappedHandler;
 	}
 };
-
 //#endregion
 export { AWSLambdaFunction, AWSLambdaQueue, AWSLambdaSubscriber, AWSScheduledFunction, AmazonApiGatewayV1Endpoint, AmazonApiGatewayV2Endpoint };
+
 //# sourceMappingURL=aws.mjs.map