@geekmidas/constructs 9.0.2 → 9.1.0

package/src/crons/CronBuilder.ts

@@ -1,16 +1,14 @@
 import type { EventPublisher } from '@geekmidas/events';
 import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
 import type { ComposableStandardSchema } from '@geekmidas/schema';
 import type { Service } from '@geekmidas/services';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import uniqBy from 'lodash.uniqby';
 import { ConstructType } from '../Construct';
+import { cloneWith } from '../clone';
 import { FunctionBuilder, type FunctionHandler } from '../functions';
 import { Cron, type ScheduleExpression } from './Cron';
 
-const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
 export class CronBuilder<
 	TInput extends ComposableStandardSchema,
 	TServices extends Service[],
@@ -39,8 +37,7 @@ export class CronBuilder<
 	}
 
 	override memorySize(memorySize: number): this {
-		this._memorySize = memorySize;
-		return this;
+		return cloneWith(this, { _memorySize: memorySize });
 	}
 
 	schedule(
@@ -55,8 +52,7 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._schedule = _expression;
-		return this;
+		return cloneWith(this, { _schedule: _expression });
 	}
 
 	override input<T extends ComposableStandardSchema>(
@@ -71,9 +67,9 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.inputSchema = schema as unknown as TInput;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			inputSchema: schema as unknown as TInput,
+		}) as unknown as CronBuilder<
 			T,
 			TServices,
 			TLogger,
@@ -97,9 +93,9 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.outputSchema = schema as unknown as OutSchema;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			outputSchema: schema as unknown as OutSchema,
+		}) as unknown as CronBuilder<
 			TInput,
 			TServices,
 			TLogger,
@@ -123,12 +119,12 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._services = uniqBy(
-			[...this._services, ...services],
-			(s) => s.serviceName,
-		) as TServices;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			_services: uniqBy(
+				[...this._services, ...services],
+				(s) => s.serviceName,
+			) as TServices,
+		}) as unknown as CronBuilder<
 			TInput,
 			[...TServices, ...T],
 			TLogger,
@@ -152,9 +148,9 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._logger = logger as unknown as TLogger;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			_logger: logger as unknown as TLogger,
+		}) as unknown as CronBuilder<
 			TInput,
 			TServices,
 			T,
@@ -178,12 +174,12 @@ export class CronBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._publisher = publisher as unknown as Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			_publisher: publisher as unknown as Service<
+				TEventPublisherServiceName,
+				TEventPublisher
+			>,
+		}) as unknown as CronBuilder<
 			TInput,
 			TServices,
 			TLogger,
@@ -211,12 +207,12 @@ export class CronBuilder<
 		T,
 		TName
 	> {
-		this._databaseService = service as unknown as Service<
-			TDatabaseServiceName,
-			TDatabase
-		>;
-
-		return this as unknown as CronBuilder<
+		return cloneWith(this, {
+			_databaseService: service as unknown as Service<
+				TDatabaseServiceName,
+				TDatabase
+			>,
+		}) as unknown as CronBuilder<
 			TInput,
 			TServices,
 			TLogger,
@@ -254,17 +250,11 @@ export class CronBuilder<
 			this._databaseService,
 		);
 
-		// Reset builder state after creating the cron to prevent pollution
-		this._services = [] as Service[] as TServices;
-		this._logger = DEFAULT_LOGGER;
-		this._events = [];
-		this._publisher = undefined;
-		this._databaseService = undefined;
-		this._schedule = undefined;
-		this.inputSchema = undefined;
-		this.outputSchema = undefined;
-		this._timeout = undefined;
-		this._memorySize = undefined;
+		// No reset. `.handle()` reads this builder and leaves it alone, so a
+		// configured base keeps its configuration for every construct built
+		// from it. The reset that used to be here wiped the base on first use.
+
+		cron.monitors = this._monitors;
 
 		return cron;
 	}

package/src/crons/__tests__/Cron.spec.ts

@@ -210,7 +210,12 @@ describe('Cron', () => {
 			const schedule: CronExpression = 'cron(0 0 * * SUN)';
 
 			const result = builder.schedule(schedule);
-			expect(result).toBe(builder); // Should return self for chaining
+
+			// A new builder carrying the schedule, so the base it came from stays
+			// clean for the next cron built off it.
+			expect(result).toBeInstanceOf(CronBuilder);
+			expect(result).not.toBe(builder);
+			expect((result as any)._schedule).toBe(schedule);
 		});
 
 		it('should build Cron with handle() method', () => {
@@ -261,7 +266,10 @@ describe('Cron', () => {
 				.schedule(schedule)
 				.input(z.object({ data: z.string() }));
 
-			expect(chained).toBe(builder);
+			expect(chained).toBeInstanceOf(CronBuilder);
+			expect(chained).not.toBe(builder);
+			expect((chained as any)._schedule).toBe(schedule);
+			expect((chained as any)._timeout).toBe(30000);
 		});
 	});
 

package/src/crons/__tests__/CronBuilder.state-isolation.spec.ts

@@ -17,6 +17,8 @@ const ServiceB = {
 	},
 } satisfies Service<'b', any>;
 
+const customLogger = new ConsoleLogger({ app: 'reusable-base' });
+
 describe('CronBuilder - State Isolation', () => {
 	describe('singleton instance state reset', () => {
 		it('should reset services after handle() is called', () => {
@@ -135,28 +137,26 @@ describe('CronBuilder - State Isolation', () => {
 		it('should not share references between different builder chains', () => {
 			const c = new CronBuilder();
 
-			// Start two separate chains
-			const builder1 = c.schedule('rate(5 minutes)').services([ServiceA]);
-			const builder2 = c.schedule('rate(10 minutes)').services([ServiceB]);
+			// Two chains off one base. They used to be the *same object* — every
+			// method mutated the base and returned it — so chain 1's function came
+			// out holding chain 2's services as well, and the base only survived
+			// because `.handle()` wiped it afterwards. That wipe is also what made
+			// a configured base unusable twice.
+			const builder1 = c.services([ServiceA]);
+			const builder2 = c.services([ServiceB]);
 
-			// They should be the same instance (singleton)
-			expect(builder1).toBe(builder2);
-			expect(builder1).toBe(c);
+			expect(builder1).not.toBe(builder2);
+			expect(builder1).not.toBe(c);
 
-			// But after handle, state is reset
-			const cron1 = builder1.handle(async () => ({}));
+			const fn1 = builder1.handle(async () => ({}));
+			const fn2 = builder2.handle(async () => ({}));
 
-			// Now builder2 should have reset state
-			expect((builder2 as any)._services).toEqual([]);
+			// Each function gets exactly what its own chain declared.
+			expect(fn1.services.map((s) => s.serviceName)).toEqual(['a']);
+			expect(fn2.services.map((s) => s.serviceName)).toEqual(['b']);
 
-			// Add services again
-			const cron2 = builder2
-				.schedule('rate(15 minutes)')
-				.services([ServiceB])
-				.handle(async () => ({}));
-
-			expect(cron1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-			expect(cron2.services.map((s) => s.serviceName)).toEqual(['b']);
+			// And the base is untouched, so it stays reusable.
+			expect((c as any)._services).toEqual([]);
 		});
 	});
 
@@ -224,4 +224,50 @@ describe('CronBuilder - State Isolation', () => {
 			expect(cron3.schedule).toBe('rate(1 hour)');
 		});
 	});
+
+	describe('a configured base, reused', () => {
+		it('carries its configuration into every cron built from it', () => {
+			const base = new CronBuilder()
+				.logger(customLogger)
+				.timeout(60_000)
+				.schedule('rate(1 day)');
+
+			const first = base.services([ServiceA]).handle(async () => ({}));
+			const second = base.services([ServiceB]).handle(async () => ({}));
+
+			// The point of the whole shape: `const base = c.logger(log)` is a base you
+			// can keep. It used to survive exactly one `.handle()` — the reset put
+			// the logger and the timeout back to their defaults — so the second
+			// cron built from it silently logged somewhere else and timed out
+			// on a different clock.
+			for (const built of [first, second]) {
+				expect(built.logger).toBe(customLogger);
+				expect(built.timeout).toBe(60_000);
+			}
+
+			// And each still gets only what its own chain declared.
+			expect(first.services.map((s) => s.serviceName)).toEqual(['a']);
+			expect(second.services.map((s) => s.serviceName)).toEqual(['b']);
+		});
+
+		it('persists configuration when handle() is called on the base itself', () => {
+			const base = new CronBuilder()
+				.logger(customLogger)
+				.timeout(60_000)
+				.schedule('rate(1 day)');
+
+			// No clone in between: `.handle()` is called straight on the base,
+			// twice. Cloning the config methods was not enough on its own —
+			// `.handle()` still ran a reset block that wiped whatever it was
+			// called on, so the second cron came back on the default logger and
+			// the default timeout.
+			const first = base.handle(async () => ({}));
+			const second = base.handle(async () => ({}));
+
+			for (const built of [first, second]) {
+				expect(built.logger).toBe(customLogger);
+				expect(built.timeout).toBe(60_000);
+			}
+		});
+	});
 });

package/src/endpoints/AmazonApiGatewayEndpointAdaptor.ts

@@ -38,6 +38,7 @@ import {
 	ServiceDiscovery,
 	type ServiceRecord,
 } from '@geekmidas/services';
+import { startMonitors } from '../monitor';
 import { publishConstructEvents } from '../publisher';
 import type { MappedAudit } from './audit';
 import type { CookieFn, HeaderFn } from './Endpoint';
@@ -134,6 +135,8 @@ export abstract class AmazonApiGatewayEndpoint<
 					'Error processing request',
 				);
 				const wrappedError = wrapError(req.error);
+				// Kept for the monitors, which only see the response otherwise.
+				(req.event as any).__error = req.error;
 
 				// Set the response with the proper status code from the HttpError
 				req.response = {
@@ -600,8 +603,26 @@ export abstract class AmazonApiGatewayEndpoint<
 
 			// Cast event to any since Middy middlewares enrich the event with
 			// services, logger, session, etc. during the middleware chain execution
-			return runWithRequestContext({ logger, requestId, startTime }, () =>
-				chain(event as unknown as Parameters<typeof chain>[0], context),
+			return runWithRequestContext(
+				{ logger, requestId, startTime },
+				async () => {
+					const monitor = await startMonitors(
+						this.endpoint,
+						ServiceDiscovery.getInstance(this.envParser),
+						logger,
+					);
+					const response = await chain(
+						event as unknown as Parameters<typeof chain>[0],
+						context,
+					);
+					// Awaited: Lambda freezes the process once the response is
+					// returned, so an unawaited ping may never be sent.
+					await monitor.settle(
+						(response as any)?.statusCode ?? 200,
+						(event as any).__error,
+					);
+					return response;
+				},
 			);
 		};
 

package/src/endpoints/EndpointBuilder.ts

@@ -10,6 +10,7 @@ import type { Service } from '@geekmidas/services';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import uniqBy from 'lodash.uniqby';
 import { ConstructType } from '../Construct';
+import { cloneWith } from '../clone';
 import { BaseFunctionBuilder } from '../functions';
 import type { HttpMethod } from '../types';
 import type { Authorizer, SecurityScheme } from './Authorizer';
@@ -102,30 +103,27 @@ export class EndpointBuilder<
 	}
 
 	description(description: string): this {
-		this._description = description;
-		return this;
+		return cloneWith(this, { _description: description });
 	}
 
 	status(status: SuccessStatus): this {
-		this._status = status;
-		return this;
+		return cloneWith(this, { _status: status });
 	}
 
 	override event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(
 		event: TEvent,
 	): this {
-		this._events.push(event);
-		return this;
+		// Replaced rather than pushed: a clone shares whatever array the field
+		// points at, so an in-place push would be seen by the base it came from.
+		return cloneWith(this, { _events: [...this._events, event] });
 	}
 
 	tags(tags: string[]): this {
-		this._tags = tags;
-		return this;
+		return cloneWith(this, { _tags: tags });
 	}
 
 	memorySize(memorySize: number): this {
-		this._memorySize = memorySize;
-		return this;
+		return cloneWith(this, { _memorySize: memorySize });
 	}
 
 	/**
@@ -147,8 +145,7 @@ export class EndpointBuilder<
 	 * ```
 	 */
 	responseType(type: string): this {
-		this._responseType = type;
-		return this;
+		return cloneWith(this, { _responseType: type });
 	}
 
 	override publisher<T extends EventPublisher<any>, TName extends string>(
@@ -170,12 +167,12 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._publisher = publisher as unknown as Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			_publisher: publisher as unknown as Service<
+				TEventPublisherServiceName,
+				TEventPublisher
+			>,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -213,9 +210,10 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.schemas.body = schema as unknown as T;
+		// A new object rather than a field set on the shared one: a clone
+		// keeps its base's `schemas` reference.
 		// @ts-expect-error
-		return this;
+		return cloneWith(this, { schemas: { ...this.schemas, body: schema } });
 	}
 
 	search<T extends StandardSchemaV1>(
@@ -237,9 +235,10 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.schemas.query = schema as unknown as T;
+		// A new object rather than a field set on the shared one: a clone
+		// keeps its base's `schemas` reference.
 		// @ts-expect-error
-		return this;
+		return cloneWith(this, { schemas: { ...this.schemas, query: schema } });
 	}
 
 	query<T extends StandardSchemaV1>(
@@ -283,21 +282,20 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.schemas.params = schema as unknown as T;
+		// A new object rather than a field set on the shared one: a clone
+		// keeps its base's `schemas` reference.
 		// @ts-expect-error
-		return this;
+		return cloneWith(this, { schemas: { ...this.schemas, params: schema } });
 	}
 
 	authorize(
 		fn: AuthorizeFn<TServices, TLogger, TSession, TInput, TDatabase>,
 	): this {
-		this._authorize = fn;
-		return this;
+		return cloneWith(this, { _authorize: fn });
 	}
 
 	rateLimit(config: RateLimitConfig): this {
-		this._rateLimit = config;
-		return this;
+		return cloneWith(this, { _rateLimit: config });
 	}
 
 	authorizer(
@@ -321,8 +319,7 @@ export class EndpointBuilder<
 	> {
 		// Special case: 'none' explicitly marks endpoint as having no authorizer
 		if (name === 'none') {
-			this._authorizerName = undefined;
-			return this;
+			return cloneWith(this, { _authorizerName: undefined });
 		}
 
 		// Validate that the authorizer exists in available authorizers
@@ -337,8 +334,7 @@ export class EndpointBuilder<
 				`Authorizer "${name as string}" not found in available authorizers: ${available}`,
 			);
 		}
-		this._authorizerName = name;
-		return this;
+		return cloneWith(this, { _authorizerName: name });
 	}
 
 	services<T extends Service[]>(
@@ -360,12 +356,12 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._services = uniqBy(
-			[...this._services, ...services],
-			(s) => s.serviceName,
-		) as TServices;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			_services: uniqBy(
+				[...this._services, ...services],
+				(s) => s.serviceName,
+			) as TServices,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -403,9 +399,9 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._logger = logger as unknown as TLogger;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			_logger: logger as unknown as TLogger,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -443,9 +439,9 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this.outputSchema = schema as unknown as OutSchema;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			outputSchema: schema as unknown as OutSchema,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -488,12 +484,12 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._auditorStorage = storage as unknown as Service<
-			TAuditStorageServiceName,
-			TAuditStorage
-		>;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			_auditorStorage: storage as unknown as Service<
+				TAuditStorageServiceName,
+				TAuditStorage
+			>,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -535,8 +531,7 @@ export class EndpointBuilder<
 		TDatabase,
 		TDatabaseServiceName
 	> {
-		this._actorExtractor = extractor;
-		return this;
+		return cloneWith(this, { _actorExtractor: extractor });
 	}
 
 	/**
@@ -557,8 +552,7 @@ export class EndpointBuilder<
 	 * ```
 	 */
 	audit(audits: MappedAudit<TAuditAction, OutSchema>[]): this {
-		this._audits = audits;
-		return this;
+		return cloneWith(this, { _audits: audits });
 	}
 
 	/**
@@ -595,12 +589,12 @@ export class EndpointBuilder<
 		T,
 		TName
 	> {
-		this._databaseService = service as unknown as Service<
-			TDatabaseServiceName,
-			TDatabase
-		>;
-
-		return this as unknown as EndpointBuilder<
+		return cloneWith(this, {
+			_databaseService: service as unknown as Service<
+				TDatabaseServiceName,
+				TDatabase
+			>,
+		}) as unknown as EndpointBuilder<
 			TRoute,
 			TMethod,
 			TInput,
@@ -642,13 +636,9 @@ export class EndpointBuilder<
 		config: RlsConfig<TServices, TSession, TLogger> | false | RlsBypass,
 	): this {
 		if (config === false || config === RLS_BYPASS) {
-			this._rlsBypass = true;
-			this._rlsConfig = undefined;
-		} else {
-			this._rlsConfig = config;
-			this._rlsBypass = false;
+			return cloneWith(this, { _rlsBypass: true, _rlsConfig: undefined });
 		}
-		return this;
+		return cloneWith(this, { _rlsConfig: config, _rlsBypass: false });
 	}
 
 	/**
@@ -665,9 +655,7 @@ export class EndpointBuilder<
 	 * ```
 	 */
 	rlsBypass(): this {
-		this._rlsBypass = true;
-		this._rlsConfig = undefined;
-		return this;
+		return cloneWith(this, { _rlsBypass: true, _rlsConfig: undefined });
 	}
 
 	// EndpointBuilder doesn't have a generic input method - it uses body, query, params instead
@@ -727,7 +715,7 @@ export class EndpointBuilder<
 			}
 		}
 
-		return new Endpoint({
+		const endpoint = new Endpoint({
 			fn,
 			method: this.method,
 			route: this.route,
@@ -754,5 +742,8 @@ export class EndpointBuilder<
 			rlsBypass: this._rlsBypass,
 			responseType: this._responseType,
 		});
+		endpoint.monitors = this._monitors;
+
+		return endpoint;
 	}
 }