@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/__tests__/publisher.spec.ts

@@ -1,452 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import { type Service, ServiceDiscovery } from '@geekmidas/services';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import { e } from '../endpoints';
-import { publishConstructEvents } from '../publisher';
-
-// Test event types
-type TestEvent =
-	| PublishableMessage<'user.created', { userId: string; email: string }>
-	| PublishableMessage<'user.updated', { userId: string; changes: string[] }>
-	| PublishableMessage<'user.deleted', { userId: string }>;
-
-describe('publishEndpointEvents', () => {
-	const mockLogger: Logger = {
-		debug: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		fatal: vi.fn(),
-		trace: vi.fn(),
-		child: vi.fn(() => mockLogger),
-	};
-	const debugSpy = mockLogger.debug as any;
-	const warnSpy = mockLogger.warn as any;
-	const errorSpy = mockLogger.error as any;
-
-	const serviceDiscovery = ServiceDiscovery.getInstance(
-		new EnvironmentParser({}),
-	);
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it('should return early when no events are defined', async () => {
-		const endpoint = e
-			.logger(mockLogger)
-			.post('/test')
-			.output(z.object({ success: z.boolean() }))
-			.handle(async () => ({ success: true }));
-
-		await publishConstructEvents(
-			endpoint,
-			{ success: true },
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(debugSpy).toHaveBeenCalledWith('No events to publish');
-	});
-
-	it('should return early when events array is empty', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn(),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(z.object({ success: z.boolean() }))
-			.handle(async () => ({ success: true }));
-
-		await publishConstructEvents(
-			endpoint,
-			{ success: true },
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(debugSpy).toHaveBeenCalledWith('No events to publish');
-		expect(mockPublisher.publish).not.toHaveBeenCalled();
-	});
-
-	it('should warn when publisher is not available', async () => {
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.post('/test')
-			.output(outputSchema)
-
-			.event({
-				// @ts-expect-error
-				type: 'user.created',
-				// @ts-expect-error
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(warnSpy).toHaveBeenCalledWith('No publisher service available');
-	});
-
-	it('should publish single event successfully', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(debugSpy).toHaveBeenCalledWith(
-			{ event: 'user.created' },
-			'Processing event',
-		);
-		expect(debugSpy).toHaveBeenCalledWith(
-			{ eventCount: 1 },
-			'Publishing events',
-		);
-		expect(mockPublisher.publish).toHaveBeenCalledWith([
-			{
-				type: 'user.created',
-				payload: { userId: '123', email: 'test@example.com' },
-			},
-		]);
-	});
-
-	it('should publish multiple events successfully', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.publisher(mockPublisherService)
-
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-			})
-			.event({
-				type: 'user.updated',
-				payload: (response) => ({ userId: response.id, changes: ['email'] }),
-			})
-
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(mockPublisher.publish).toHaveBeenCalledWith([
-			{
-				type: 'user.created',
-				payload: { userId: '123', email: 'test@example.com' },
-			},
-			{
-				type: 'user.updated',
-				payload: { userId: '123', changes: ['email'] },
-			},
-		]);
-	});
-
-	it('should respect when condition for events', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({
-			id: z.string(),
-			email: z.string(),
-			isNew: z.boolean(),
-		});
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-				when: (response) => response.isNew === true,
-			})
-			.event({
-				type: 'user.updated',
-				payload: (response) => ({ userId: response.id, changes: ['email'] }),
-				when: (response) => response.isNew === false,
-			})
-			.handle(async () => ({
-				id: '123',
-				email: 'test@example.com',
-				isNew: false,
-			}));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-				isNew: false,
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		// Only the user.updated event should be published
-		expect(mockPublisher.publish).toHaveBeenCalledWith([
-			{
-				type: 'user.updated',
-				payload: { userId: '123', changes: ['email'] },
-			},
-		]);
-	});
-
-	it('should not publish any events when all when conditions are false', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-				when: () => false,
-			})
-			.event({
-				type: 'user.updated',
-				payload: (response) => ({ userId: response.id, changes: ['email'] }),
-				when: () => false,
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(mockPublisher.publish).not.toHaveBeenCalled();
-	});
-
-	it('should handle async payload functions', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					// Simulate async operation
-					userId: response.id,
-					email: response.email,
-				}),
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(mockPublisher.publish).toHaveBeenCalledWith([
-			{
-				type: 'user.created',
-				payload: { userId: '123', email: 'test@example.com' },
-			},
-		]);
-	});
-
-	it('should catch and log publish errors', async () => {
-		const publishError = new Error('Failed to connect to event bus');
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockRejectedValue(publishError),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		// Should not throw
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(errorSpy).toHaveBeenCalledWith(
-			publishError,
-			'Failed to publish events',
-		);
-	});
-
-	it('should preserve additional event properties', async () => {
-		const mockPublisher: EventPublisher<TestEvent> = {
-			publish: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-			serviceName: Math.random().toString(),
-			register: vi.fn().mockResolvedValue(mockPublisher),
-		};
-
-		const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-		const endpoint = e
-			.logger(mockLogger)
-			.publisher(mockPublisherService)
-			.post('/test')
-			.output(outputSchema)
-			.event({
-				type: 'user.created',
-				payload: (response) => ({
-					userId: response.id,
-					email: response.email,
-				}),
-				// Additional properties that should be preserved
-				metadata: { source: 'api', version: '1.0' },
-				priority: 'high',
-			})
-			.handle(async () => ({ id: '123', email: 'test@example.com' }));
-
-		await publishConstructEvents(
-			endpoint,
-			{
-				id: '123',
-				email: 'test@example.com',
-			},
-			serviceDiscovery as ServiceDiscovery<any, any>,
-		);
-
-		expect(mockPublisher.publish).toHaveBeenCalledWith([
-			{
-				type: 'user.created',
-				payload: { userId: '123', email: 'test@example.com' },
-				metadata: { source: 'api', version: '1.0' },
-				priority: 'high',
-			},
-		]);
-	});
-});

package/src/adaptors/aws.ts

@@ -1,6 +0,0 @@
-export { AWSScheduledFunction } from '../crons/AWSScheduledFunction';
-export { AmazonApiGatewayV1Endpoint } from '../endpoints/AmazonApiGatewayV1EndpointAdaptor';
-export { AmazonApiGatewayV2Endpoint } from '../endpoints/AmazonApiGatewayV2EndpointAdaptor';
-export { AWSLambdaFunction } from '../functions/AWSLambdaFunction';
-export { AWSLambdaQueue } from '../queue/AWSLambdaQueueAdaptor';
-export { AWSLambdaSubscriber } from '../subscribers/AWSLambdaSubscriberAdaptor';

package/src/adaptors/hono.ts

@@ -1 +0,0 @@
-export { HonoEndpoint } from '../endpoints/HonoEndpointAdaptor';

package/src/adaptors/testing.ts

@@ -1,11 +0,0 @@
-export {
-	type CreateMswHandlersOptions,
-	type CreateMswHandlersResult,
-	createMswHandlers,
-	type RegisterContextOptions,
-	TEST_CONTEXT_HEADER,
-} from '../endpoints/MswEndpointAdaptor';
-export { TestEndpointAdaptor } from '../endpoints/TestEndpointAdaptor';
-export { TestFunctionAdaptor } from '../functions/TestFunctionAdaptor';
-export { TestQueueAdaptor } from '../queue/TestQueueAdaptor';
-export { TestSubscriberAdaptor } from '../subscribers/TestSubscriberAdaptor';

package/src/crons/AWSScheduledFunction.ts

@@ -1,73 +0,0 @@
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type { ComposableStandardSchema } from '@geekmidas/schema';
-import type { Service } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { AWSLambdaFunction } from '../functions/AWSLambdaFunction';
-import type { Cron } from './Cron';
-
-/**
- * AWS Lambda adaptor for {@link Cron} constructs.
- *
- * A `Cron` is a {@link import('../functions').Function} that is invoked on a
- * schedule (an EventBridge rule) rather than by an API request. Because of
- * that, the runtime execution pipeline is identical to a regular Lambda
- * function: input parsing, service/database/auditor wiring, event publishing,
- * error handling, and the `runWithRequestContext` wrapper that powers
- * request-scoped logging via `serviceContext.getLogger()`.
- *
- * This adaptor therefore reuses {@link AWSLambdaFunction} wholesale and only
- * narrows the constructor to accept a `Cron`. The schedule expression itself
- * (`cron.schedule`) is **deploy-time** infrastructure consumed by the CLI to
- * provision the EventBridge rule — it is not needed at runtime.
- *
- * @example
- * ```typescript
- * import { AWSScheduledFunction } from '@geekmidas/constructs/crons';
- * import { cancelPastBookings } from '../../../src/crons/cancelPastBookings.js';
- * import { envParser } from '../../../src/env';
- *
- * const adapter = new AWSScheduledFunction(envParser, cancelPastBookings);
- *
- * export const handler = adapter.handler;
- * ```
- */
-export class AWSScheduledFunction<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	TOutSchema extends StandardSchemaV1 | undefined = undefined,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TDatabase = undefined,
-	TDatabaseServiceName extends string = string,
-> extends AWSLambdaFunction<
-	TInput,
-	TOutSchema,
-	TServices,
-	TLogger,
-	TEventPublisher,
-	TEventPublisherServiceName,
-	undefined,
-	string,
-	TDatabase,
-	TDatabaseServiceName
-> {
-	// biome-ignore lint/complexity/noUselessConstructor: narrows the inherited `Function` parameter to `Cron` for a clearer public API
-	constructor(
-		envParser: EnvironmentParser<{}>,
-		cron: Cron<
-			TInput,
-			TServices,
-			TLogger,
-			TOutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>,
-	) {
-		super(envParser, cron);
-	}
-}

package/src/crons/Cron.ts

@@ -1,149 +0,0 @@
-import type { AuditableAction } from '@geekmidas/audit';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type { ComposableStandardSchema } from '@geekmidas/schema';
-import type { Service } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-
-import { ConstructType } from '../Construct';
-import { Function, type FunctionHandler } from '../functions';
-
-export class Cron<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TDatabase = undefined,
-	TDatabaseServiceName extends string = string,
-> extends Function<
-	TInput,
-	TServices,
-	TLogger,
-	OutSchema,
-	TEventPublisher,
-	TEventPublisherServiceName,
-	undefined,
-	string,
-	TDatabase,
-	TDatabaseServiceName,
-	AuditableAction<string, unknown>,
-	FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>
-> {
-	static isCron(obj: any): obj is Cron<any, any, any, any> {
-		return Boolean(
-			obj &&
-				(obj as Function).__IS_FUNCTION__ === true &&
-				obj.type === ConstructType.Cron,
-		);
-	}
-
-	constructor(
-		fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>,
-		timeout?: number,
-		protected _schedule?: ScheduleExpression,
-		input?: TInput,
-		outputSchema?: OutSchema,
-		services: TServices = [] as unknown as TServices,
-		logger?: TLogger,
-		publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
-		events: any[] = [],
-		memorySize?: number,
-		databaseService?: Service<TDatabaseServiceName, TDatabase>,
-	) {
-		super(
-			fn,
-			timeout,
-			ConstructType.Cron,
-			input,
-			outputSchema,
-			services,
-			logger,
-			publisherService,
-			events,
-			memorySize,
-			undefined, // auditorStorageService
-			databaseService,
-		);
-	}
-
-	get schedule(): ScheduleExpression | undefined {
-		return this._schedule;
-	}
-}
-
-export type RateExpression = `rate(${string})`;
-
-type CronMinute =
-	| '*'
-	| number
-	| `${number}`
-	| `${number}-${number}`
-	| `${number}/${number}`
-	| `*/${number}`
-	| `${number},${number}`
-	| string; // Allow more complex patterns
-
-type CronHour =
-	| '*'
-	| number
-	| `${number}`
-	| `${number}-${number}`
-	| `${number}/${number}`
-	| `*/${number}`
-	| `${number},${number}`
-	| string; // Allow more complex patterns
-
-type CronDay =
-	| '*'
-	| number
-	| `${number}`
-	| `${number}-${number}`
-	| `${number}/${number}`
-	| `*/${number}`
-	| `${number},${number}`
-	| string; // Allow more complex patterns
-
-type CronMonth =
-	| '*'
-	| number
-	| `${number}`
-	| `${number}-${number}`
-	| `${number}/${number}`
-	| `*/${number}`
-	| 'JAN'
-	| 'FEB'
-	| 'MAR'
-	| 'APR'
-	| 'MAY'
-	| 'JUN'
-	| 'JUL'
-	| 'AUG'
-	| 'SEP'
-	| 'OCT'
-	| 'NOV'
-	| 'DEC'
-	| string; // Allow more complex patterns
-
-type CronWeekday =
-	| '*'
-	| number
-	| `${number}`
-	| `${number}-${number}`
-	| `${number}/${number}`
-	| `*/${number}`
-	| 'SUN'
-	| 'MON'
-	| 'TUE'
-	| 'WED'
-	| 'THU'
-	| 'FRI'
-	| 'SAT'
-	| `${string}-${string}` // Allow patterns like MON-FRI
-	| string; // Allow more complex patterns
-
-export type CronExpression =
-	`cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;
-
-export type ScheduleExpression = RateExpression | CronExpression;