@geekmidas/constructs 1.0.4 → 1.1.0

package/dist/subscribers/index.d.mts

@@ -1,6 +1,7 @@
-import "../Construct-DvXCkLOP.mjs";
-import { Subscriber } from "../Subscriber-DCgMSkQA.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-BcyK44e_.mjs";
+import "../Construct-C2SyofdS.mjs";
+import { Subscriber } from "../Subscriber-BgB3RRxb.mjs";
+import { TestSubscriberAdaptor } from "../TestSubscriberAdaptor-CPEiqSfE.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-DaQkh2Nt.mjs";
 import * as _geekmidas_logger10 from "@geekmidas/logger";
 
 //#region src/subscribers/index.d.ts
@@ -8,5 +9,5 @@ declare const s: SubscriberBuilder<[], _geekmidas_logger10.Logger, undefined, un
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { Subscriber, SubscriberBuilder, s };
+export { Subscriber, SubscriberBuilder, TestSubscriberAdaptor, s };
 //# sourceMappingURL=index.d.mts.map

package/dist/subscribers/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/subscribers/index.ts"],"sourcesContent":[],"mappings":";;;;;;cAKa,GAAC,sBAA0B,mBAAA,CAA1B,MAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/subscribers/index.ts"],"sourcesContent":[],"mappings":";;;;;;;cAMa,GAAC,sBAA0B,mBAAA,CAA1B,MAAA"}

package/dist/subscribers/index.mjs

@@ -1,10 +1,12 @@
 import "../Construct-CQ9zV58W.mjs";
-import { Subscriber } from "../Subscriber-DKQK5gLD.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-BswTuvUc.mjs";
+import "../publisher-Bw4770Hi.mjs";
+import { TestSubscriberAdaptor } from "../TestSubscriberAdaptor-CrqLkyUE.mjs";
+import { Subscriber } from "../Subscriber-BEhOdNQi.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-DlUaG0Ej.mjs";
 
 //#region src/subscribers/index.ts
 const s = new SubscriberBuilder();
 
 //#endregion
-export { Subscriber, SubscriberBuilder, s };
+export { Subscriber, SubscriberBuilder, TestSubscriberAdaptor, s };
 //# sourceMappingURL=index.mjs.map

package/dist/subscribers/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/subscribers/index.ts"],"sourcesContent":["import { SubscriberBuilder } from './SubscriberBuilder';\n\nexport { Subscriber } from './Subscriber';\nexport { SubscriberBuilder };\n\nexport const s = new SubscriberBuilder();\n"],"mappings":";;;;;AAKA,MAAa,IAAI,IAAI"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/subscribers/index.ts"],"sourcesContent":["import { SubscriberBuilder } from './SubscriberBuilder';\n\nexport { Subscriber } from './Subscriber';\nexport { SubscriberBuilder };\nexport { TestSubscriberAdaptor } from './TestSubscriberAdaptor';\n\nexport const s = new SubscriberBuilder();\n"],"mappings":";;;;;;;AAMA,MAAa,IAAI,IAAI"}

package/dist/{telemetry-yAHf5yDs.d.mts → telemetry-C-kNOW3C.d.mts}

@@ -92,4 +92,4 @@ interface Telemetry {
 //# sourceMappingURL=telemetry.d.ts.map
 //#endregion
 export { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse };
-//# sourceMappingURL=telemetry-yAHf5yDs.d.mts.map
+//# sourceMappingURL=telemetry-C-kNOW3C.d.mts.map

package/dist/{telemetry-yAHf5yDs.d.mts.map → telemetry-C-kNOW3C.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"telemetry-yAHf5yDs.d.mts","names":[],"sources":["../src/telemetry.ts"],"sourcesContent":[],"mappings":";;;;;;;AA6FmB,UAlFF,gBAAA,CAkFE;EAAgB;;;EAQgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;;UAhFlC,gBAAA;;;;;;;;WASP;;;;;UAMO,iBAAA;;;;;;;;;;;;YAcN;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BM,SAAA;;;;;;;0BAOQ,mBAAmB;;;;;;;oBAQzB,4BAA4B;;;;;;;sBAQ1B,yBAAyB"}
+{"version":3,"file":"telemetry-C-kNOW3C.d.mts","names":[],"sources":["../src/telemetry.ts"],"sourcesContent":[],"mappings":";;;;;;;AA6FmB,UAlFF,gBAAA,CAkFE;EAAgB;;;EAQgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;;UAhFlC,gBAAA;;;;;;;;WASP;;;;;UAMO,iBAAA;;;;;;;;;;;;YAcN;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BM,SAAA;;;;;;;0BAOQ,mBAAmB;;;;;;;oBAQzB,4BAA4B;;;;;;;sBAQ1B,yBAAyB"}

package/dist/telemetry.d.mts

@@ -1,2 +1,2 @@
-import { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse } from "./telemetry-yAHf5yDs.mjs";
+import { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse } from "./telemetry-C-kNOW3C.mjs";
 export { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse };

package/dist/{types-Dw-iLd3Y.d.mts → types-aFmq5cKh.d.mts}

@@ -6,4 +6,4 @@ type LowerHttpMethod<T extends HttpMethod> = Lowercase<T>;
 
 //#endregion
 export { HttpMethod, LowerHttpMethod, RemoveUndefined };
-//# sourceMappingURL=types-Dw-iLd3Y.d.mts.map
+//# sourceMappingURL=types-aFmq5cKh.d.mts.map

package/dist/{types-Dw-iLd3Y.d.mts.map → types-aFmq5cKh.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-Dw-iLd3Y.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,6BAAA,MACC,CADD,IACM,CADS,CACP,CADO,CAAA,SAAA,SAAA,GAAA,KAAA,GACwB,CADxB,GAC4B,CAD5B,CAC8B,CAD9B,CAAA,EAAA;AACd,KAGD,UAAA,GAHC,KAAA,GAAA,MAAA,GAAA,KAAA,GAAA,OAAA,GAAA,QAAA,GAAA,SAAA;AAAK,KAWN,eAXM,CAAA,UAWoB,UAXpB,CAAA,GAWkC,SAXlC,CAW4C,CAX5C,CAAA"}
+{"version":3,"file":"types-aFmq5cKh.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,6BAAA,MACC,CADD,IACM,CADS,CACP,CADO,CAAA,SAAA,SAAA,GAAA,KAAA,GACwB,CADxB,GAC4B,CAD5B,CAC8B,CAD9B,CAAA,EAAA;AACd,KAGD,UAAA,GAHC,KAAA,GAAA,MAAA,GAAA,KAAA,GAAA,OAAA,GAAA,QAAA,GAAA,SAAA;AAAK,KAWN,eAXM,CAAA,UAWoB,UAXpB,CAAA,GAWkC,SAXlC,CAW4C,CAX5C,CAAA"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-Dw-iLd3Y.mjs";
+import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-aFmq5cKh.mjs";
 export { HttpMethod, LowerHttpMethod, RemoveUndefined };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/constructs",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -74,21 +74,21 @@
     "@types/lodash.set": "~4.3.9",
     "@types/lodash.uniqby": "~4.7.9",
     "@types/pg": "~8.15.6",
-    "better-auth": "~1.4.12",
+    "better-auth": "~1.4.18",
     "kysely": "~0.28.8",
     "pg": "~8.16.3",
     "zod": "~4.1.13",
     "@geekmidas/audit": "^1.0.0",
     "@geekmidas/cache": "^1.0.0",
-    "@geekmidas/db": "^1.0.0",
-    "@geekmidas/envkit": "^1.0.1",
+    "@geekmidas/envkit": "^1.0.2",
     "@geekmidas/errors": "^1.0.0",
+    "@geekmidas/db": "^1.0.0",
     "@geekmidas/events": "^1.0.0",
     "@geekmidas/logger": "^1.0.0",
     "@geekmidas/rate-limit": "^1.0.0",
-    "@geekmidas/services": "^1.0.0",
-    "@geekmidas/testkit": "^1.0.1",
-    "@geekmidas/schema": "^1.0.0"
+    "@geekmidas/schema": "^1.0.0",
+    "@geekmidas/services": "^1.0.1",
+    "@geekmidas/testkit": "^1.0.1"
   },
   "peerDependencies": {
     "@middy/core": ">=6.3.1",
@@ -97,13 +97,13 @@
     "@geekmidas/audit": "^1.0.0",
     "@geekmidas/cache": "^1.0.0",
     "@geekmidas/db": "^1.0.0",
+    "@geekmidas/envkit": "^1.0.2",
     "@geekmidas/errors": "^1.0.0",
     "@geekmidas/events": "^1.0.0",
-    "@geekmidas/envkit": "^1.0.1",
     "@geekmidas/logger": "^1.0.0",
+    "@geekmidas/rate-limit": "^1.0.0",
     "@geekmidas/schema": "^1.0.0",
-    "@geekmidas/services": "^1.0.0",
-    "@geekmidas/rate-limit": "^1.0.0"
+    "@geekmidas/services": "^1.0.1"
   },
   "peerDependenciesMeta": {
     "@geekmidas/audit": {

package/src/adaptors/testing.ts

@@ -1 +1,3 @@
 export { TestEndpointAdaptor } from '../endpoints/TestEndpointAdaptor';
+export { TestFunctionAdaptor } from '../functions/TestFunctionAdaptor';
+export { TestSubscriberAdaptor } from '../subscribers/TestSubscriberAdaptor';

package/src/endpoints/EndpointFactory.ts

@@ -485,7 +485,7 @@ export class EndpointFactory<
 		TDatabase,
 		TDatabaseServiceName,
 		TSecuritySchemes,
-		undefined // Reset RLS config when services change - user should call .rls() after .services()
+		RlsConfig<[...S, ...TServices], TSession, TLogger> | undefined
 	> {
 		return new EndpointFactory<
 			[...S, ...TServices],
@@ -501,7 +501,7 @@ export class EndpointFactory<
 			TDatabase,
 			TDatabaseServiceName,
 			TSecuritySchemes,
-			undefined
+			RlsConfig<[...S, ...TServices], TSession, TLogger> | undefined
 		>({
 			defaultServices: [...services, ...this.defaultServices],
 			basePath: this.basePath,
@@ -523,8 +523,9 @@ export class EndpointFactory<
 				| ActorExtractor<[...S, ...TServices], TSession, TLogger>
 				| undefined,
 			customSecuritySchemes: this.customSecuritySchemes,
-			// Reset RLS config when services change since it depends on TServices
-			defaultRlsConfig: undefined,
+			defaultRlsConfig: this.defaultRlsConfig as unknown as
+				| RlsConfig<[...S, ...TServices], TSession, TLogger>
+				| undefined,
 		});
 	}
 
@@ -544,7 +545,7 @@ export class EndpointFactory<
 		TDatabase,
 		TDatabaseServiceName,
 		TSecuritySchemes,
-		undefined // Reset RLS config when logger type changes - user should call .rls() after .logger()
+		RlsConfig<TServices, TSession, L> | undefined
 	> {
 		return new EndpointFactory<
 			TServices,
@@ -560,7 +561,7 @@ export class EndpointFactory<
 			TDatabase,
 			TDatabaseServiceName,
 			TSecuritySchemes,
-			undefined
+			RlsConfig<TServices, TSession, L> | undefined
 		>({
 			defaultServices: this.defaultServices,
 			basePath: this.basePath,
@@ -588,8 +589,9 @@ export class EndpointFactory<
 				L
 			>,
 			customSecuritySchemes: this.customSecuritySchemes,
-			// Reset RLS config when logger type changes since it depends on TLogger
-			defaultRlsConfig: undefined,
+			defaultRlsConfig: this.defaultRlsConfig as unknown as
+				| RlsConfig<TServices, TSession, L>
+				| undefined,
 		});
 	}
 
@@ -662,7 +664,7 @@ export class EndpointFactory<
 		TDatabase,
 		TDatabaseServiceName,
 		TSecuritySchemes,
-		undefined // Reset RLS config when session type changes - user should call .rls() after .session()
+		RlsConfig<TServices, T, TLogger> | undefined
 	> {
 		return new EndpointFactory<
 			TServices,
@@ -678,7 +680,7 @@ export class EndpointFactory<
 			TDatabase,
 			TDatabaseServiceName,
 			TSecuritySchemes,
-			undefined
+			RlsConfig<TServices, T, TLogger> | undefined
 		>({
 			defaultServices: this.defaultServices,
 			basePath: this.basePath,
@@ -701,8 +703,9 @@ export class EndpointFactory<
 				TLogger
 			>,
 			customSecuritySchemes: this.customSecuritySchemes,
-			// Reset RLS config when session type changes since it depends on TSession
-			defaultRlsConfig: undefined,
+			defaultRlsConfig: this.defaultRlsConfig as unknown as
+				| RlsConfig<TServices, T, TLogger>
+				| undefined,
 		});
 	}
 

package/src/subscribers/AWSLambdaSubscriberAdaptor.ts

@@ -145,7 +145,7 @@ export class AWSLambdaSubscriber<
 						for (const record of rawEvent.Records) {
 							try {
 								const event = this.parseSQSRecord(record);
-								if (event && this.isSubscribedEvent(event.type)) {
+								if (this.shouldIncludeEvent(event)) {
 									events.push(event);
 								}
 							} catch (error) {
@@ -160,7 +160,7 @@ export class AWSLambdaSubscriber<
 						for (const record of rawEvent.Records) {
 							try {
 								const event = this.parseSNSRecord(record);
-								if (event && this.isSubscribedEvent(event.type)) {
+								if (this.shouldIncludeEvent(event)) {
 									events.push(event);
 								}
 							} catch (error) {
@@ -200,59 +200,83 @@ export class AWSLambdaSubscriber<
 		);
 	}
 
-	private parseSNSRecord(record: SNSEventRecord): any | null {
-		try {
-			const message = JSON.parse(record.Sns.Message);
-			// Resolve type from MessageAttributes (preferred) or message body
-			const messageType =
-				record.Sns.MessageAttributes?.type?.Value ?? message.type;
+	private parseSNSRecord(record: SNSEventRecord): any {
+		const message = this.safeJsonParse(record.Sns.Message);
+		const messageType = record.Sns.MessageAttributes?.type?.Value;
 
-			if (message.type) {
-				return message; // Full event format: { type, payload }
-			}
+		// Not JSON — wrap raw string with type from MessageAttributes if available
+		if (message === null) {
+			return messageType
+				? { type: messageType, payload: record.Sns.Message }
+				: record.Sns.Message;
+		}
 
-			// Payload-only format: type is in MessageAttributes
-			return messageType ? { type: messageType, payload: message } : message;
-		} catch (error) {
-			this.logger.error({ error, record }, 'Failed to parse SNS record body');
-			return null;
+		// Resolve type from MessageAttributes (preferred) or message body
+		const resolvedType = messageType ?? message.type;
+
+		if (message.type) {
+			return message; // Full event format: { type, payload }
 		}
+
+		// Payload-only format: type is in MessageAttributes
+		return resolvedType ? { type: resolvedType, payload: message } : message;
 	}
 
-	private parseSQSRecord(record: SQSRecord): any | null {
-		try {
-			const body = JSON.parse(record.body);
+	private parseSQSRecord(record: SQSRecord): any {
+		const body = this.safeJsonParse(record.body);
 
-			// Check if this is an SNS message wrapped in SQS
-			if (body.Type === 'Notification' && body.Message) {
-				const snsMessage = JSON.parse(body.Message);
+		// Not JSON — return raw body as-is
+		if (body === null) {
+			return record.body;
+		}
 
-				if (snsMessage.type) {
-					return snsMessage; // Full event format: { type, payload }
-				}
+		// Check if this is an SNS message wrapped in SQS
+		if (body.Type === 'Notification' && body.Message) {
+			const snsMessage = this.safeJsonParse(body.Message);
+			const messageType = body.MessageAttributes?.type?.Value;
 
-				// Payload-only format: type is in MessageAttributes
-				const messageType =
-					body.MessageAttributes?.type?.Value ?? snsMessage.type;
+			// SNS Message not JSON — wrap with type from MessageAttributes if available
+			if (snsMessage === null) {
 				return messageType
-					? { type: messageType, payload: snsMessage }
-					: snsMessage;
+					? { type: messageType, payload: body.Message }
+					: body.Message;
 			}
 
-			// Direct SQS message
-			return body;
-		} catch (error) {
-			this.logger.error({ error, record }, 'Failed to parse SQS record body');
+			if (snsMessage.type) {
+				return snsMessage; // Full event format: { type, payload }
+			}
+
+			// Payload-only format: type is in MessageAttributes
+			const resolvedType = messageType ?? snsMessage.type;
+			return resolvedType
+				? { type: resolvedType, payload: snsMessage }
+				: snsMessage;
+		}
+
+		// Direct SQS message
+		return body;
+	}
+
+	private safeJsonParse(value: string): any | null {
+		try {
+			return JSON.parse(value);
+		} catch {
 			return null;
 		}
 	}
 
-	private isSubscribedEvent(eventType: string): boolean {
+	private shouldIncludeEvent(event: any): boolean {
+		// No event type (raw string/non-object) — always include
+		if (typeof event !== 'object' || !event?.type) {
+			return true;
+		}
+
+		// No filter configured — accept all
 		if (!this.subscriber.subscribedEvents) {
-			return true; // If no events specified, accept all
+			return true;
 		}
 
-		return this.subscriber.subscribedEvents.includes(eventType as any);
+		return this.subscriber.subscribedEvents.includes(event.type as any);
 	}
 
 	private async _handler(event: SubscriberEvent<TServices, TLogger>) {

package/src/subscribers/TestSubscriberAdaptor.ts

@@ -0,0 +1,127 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type {
+	EventPublisher,
+	ExtractPublisherMessage,
+} from '@geekmidas/events';
+import type { Logger } from '@geekmidas/logger';
+import type { InferStandardSchema } from '@geekmidas/schema';
+import type { Service, ServiceRecord } from '@geekmidas/services';
+import { ServiceDiscovery } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { publishEvents } from '../publisher';
+import type { Subscriber } from './Subscriber';
+
+// 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 TestSubscriberAdaptor<
+	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'][],
+> {
+	static getDefaultServiceDiscovery() {
+		return ServiceDiscovery.getInstance(new EnvironmentParser({}));
+	}
+
+	constructor(
+		private readonly subscriber: Subscriber<
+			TServices,
+			TLogger,
+			OutSchema,
+			TEventPublisher,
+			TEventPublisherServiceName,
+			TSubscribedEvents
+		>,
+		private serviceDiscovery: ServiceDiscovery<any> = TestSubscriberAdaptor.getDefaultServiceDiscovery(),
+	) {}
+
+	async invoke(
+		request: TestSubscriberRequest<
+			TEventPublisher,
+			TSubscribedEvents,
+			TServices
+		>,
+	): Promise<InferStandardSchema<OutSchema>> {
+		// Create logger with test context
+		const logger = this.subscriber.logger.child({
+			test: true,
+		}) as TLogger;
+
+		// Resolve services (use provided or auto-register)
+		let services: ServiceRecord<TServices>;
+		if (request.services) {
+			services = request.services;
+		} else {
+			services = await this.serviceDiscovery.register(this.subscriber.services);
+		}
+
+		// Filter events to only subscribed types
+		const filteredEvents = this.filterEvents(request.events);
+
+		// Return early if no events after filtering (mirrors AWSLambdaSubscriber)
+		if (filteredEvents.length === 0) {
+			return { batchItemFailures: [] } as any;
+		}
+
+		// Execute the subscriber handler
+		const result = await this.subscriber.handler({
+			events: filteredEvents,
+			services,
+			logger,
+		});
+
+		// Validate output if schema is provided
+		let output = result;
+		if (this.subscriber.outputSchema && result) {
+			const validationResult =
+				await this.subscriber.outputSchema['~standard'].validate(result);
+
+			if (validationResult.issues) {
+				throw new Error('Subscriber output validation failed');
+			}
+
+			output = validationResult.value;
+		}
+
+		// Publish events if configured
+		await publishEvents(
+			logger,
+			this.serviceDiscovery,
+			this.subscriber.events,
+			output,
+			this.subscriber.publisherService,
+		);
+
+		return output;
+	}
+
+	private filterEvents(
+		events: ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[],
+	): ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[] {
+		if (!this.subscriber.subscribedEvents) {
+			return events;
+		}
+
+		return events.filter((event: any) =>
+			this.subscriber.subscribedEvents!.includes(event.type),
+		);
+	}
+}
+
+export type TestSubscriberRequest<
+	TEventPublisher extends EventPublisher<any> | undefined = undefined,
+	TSubscribedEvents extends any[] = [],
+	TServices extends Service[] = [],
+> = {
+	events: ExtractEventPayloads<TEventPublisher, TSubscribedEvents>[];
+	services?: ServiceRecord<TServices>;
+};