@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/crons/CronBuilder.ts

@@ -1,271 +0,0 @@
-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 { 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[],
-	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 FunctionBuilder<
-	TInput,
-	OutSchema,
-	TServices,
-	TLogger,
-	TEventPublisher,
-	TEventPublisherServiceName,
-	undefined,
-	string,
-	TDatabase,
-	TDatabaseServiceName
-> {
-	private _schedule?: ScheduleExpression;
-
-	constructor() {
-		super(ConstructType.Cron);
-	}
-
-	override memorySize(memorySize: number): this {
-		this._memorySize = memorySize;
-		return this;
-	}
-
-	schedule(
-		_expression: ScheduleExpression,
-	): CronBuilder<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._schedule = _expression;
-		return this;
-	}
-
-	override input<T extends ComposableStandardSchema>(
-		schema: T,
-	): CronBuilder<
-		T,
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this.inputSchema = schema as unknown as TInput;
-
-		return this as unknown as CronBuilder<
-			T,
-			TServices,
-			TLogger,
-			OutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	override output<T extends StandardSchemaV1>(
-		schema: T,
-	): CronBuilder<
-		TInput,
-		TServices,
-		TLogger,
-		T,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this.outputSchema = schema as unknown as OutSchema;
-
-		return this as unknown as CronBuilder<
-			TInput,
-			TServices,
-			TLogger,
-			T,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	override services<T extends Service[]>(
-		services: T,
-	): CronBuilder<
-		TInput,
-		[...TServices, ...T],
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._services = uniqBy(
-			[...this._services, ...services],
-			(s) => s.serviceName,
-		) as TServices;
-
-		return this as unknown as CronBuilder<
-			TInput,
-			[...TServices, ...T],
-			TLogger,
-			OutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	override logger<T extends Logger>(
-		logger: T,
-	): CronBuilder<
-		TInput,
-		TServices,
-		T,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._logger = logger as unknown as TLogger;
-
-		return this as unknown as CronBuilder<
-			TInput,
-			TServices,
-			T,
-			OutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	override publisher<T extends EventPublisher<any>, TName extends string>(
-		publisher: Service<TName, T>,
-	): CronBuilder<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		T,
-		TName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._publisher = publisher as unknown as Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>;
-
-		return this as unknown as CronBuilder<
-			TInput,
-			TServices,
-			TLogger,
-			OutSchema,
-			T,
-			TName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	/**
-	 * Set the database service for this cron job.
-	 * The database will be available in the handler context as `db`.
-	 */
-	override database<T, TName extends string>(
-		service: Service<TName, T>,
-	): CronBuilder<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		T,
-		TName
-	> {
-		this._databaseService = service as unknown as Service<
-			TDatabaseServiceName,
-			TDatabase
-		>;
-
-		return this as unknown as CronBuilder<
-			TInput,
-			TServices,
-			TLogger,
-			OutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			T,
-			TName
-		>;
-	}
-
-	override handle(
-		fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>,
-	): Cron<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		const cron = new Cron(
-			fn,
-			this._timeout,
-			this._schedule,
-			this.inputSchema,
-			this.outputSchema,
-			this._services,
-			this._logger,
-			this._publisher,
-			this._events,
-			this._memorySize,
-			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;
-
-		return cron;
-	}
-}

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

@@ -1,152 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import type { Service } from '@geekmidas/services';
-import { ServiceDiscovery, serviceContext } from '@geekmidas/services';
-import type { Context } from 'aws-lambda';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import { AWSScheduledFunction } from '../AWSScheduledFunction';
-import { CronBuilder } from '../CronBuilder';
-
-/** Spy logger whose `child()` returns itself, so all log calls land on it. */
-function makeSpyLogger(): Logger {
-	const logger: Logger = {
-		trace: vi.fn(),
-		debug: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		fatal: vi.fn(),
-		child: vi.fn(() => logger),
-	};
-	return logger;
-}
-
-// Minimal EventBridge scheduled-event envelope (no user payload).
-const scheduledEvent = {
-	id: 'cdc73f9d-aea9-11e3-9d5a-835b769c0d9c',
-	version: '0',
-	account: '123456789012',
-	time: '2026-06-09T00:00:00Z',
-	region: 'us-east-1',
-	source: 'aws.events',
-	resources: ['arn:aws:events:us-east-1:123456789012:rule/daily'],
-	'detail-type': 'Scheduled Event',
-	detail: {},
-};
-
-const createMockContext = (): Context =>
-	({
-		functionName: 'cancelPastBookings',
-		functionVersion: '1',
-		invokedFunctionArn:
-			'arn:aws:lambda:us-east-1:123456789012:function:cancelPastBookings',
-		memoryLimitInMB: '128',
-		awsRequestId: 'test-request-id',
-		logGroupName: '/aws/lambda/cancelPastBookings',
-		logStreamName: '2026/06/09/[$LATEST]test-stream',
-		getRemainingTimeInMillis: () => 30000,
-		done: vi.fn(),
-		fail: vi.fn(),
-		succeed: vi.fn(),
-		callbackWaitsForEmptyEventLoop: true,
-	}) as unknown as Context;
-
-class CounterService implements Service<'counter', CounterService> {
-	serviceName = 'counter' as const;
-	count = 0;
-	async register() {
-		return this;
-	}
-	increment() {
-		this.count += 1;
-		return this.count;
-	}
-}
-
-describe('AWSScheduledFunction', () => {
-	let envParser: EnvironmentParser<{}>;
-
-	beforeEach(() => {
-		// ServiceDiscovery is a process-wide singleton that caches resolved
-		// instances; reset so each test (and ordering) starts clean.
-		ServiceDiscovery.reset();
-		envParser = new EnvironmentParser({});
-		vi.clearAllMocks();
-	});
-
-	it('runs the cron handler on a scheduled event', async () => {
-		const ran = vi.fn();
-		const cron = new CronBuilder().schedule('rate(1 day)').handle(async () => {
-			ran();
-		});
-
-		const adapter = new AWSScheduledFunction(envParser, cron);
-		const result = await adapter.handler(
-			scheduledEvent,
-			createMockContext(),
-			vi.fn(),
-		);
-
-		expect(ran).toHaveBeenCalledTimes(1);
-		// With no output schema the adaptor returns undefined, matching
-		// AWSLambdaFunction — crons typically don't return a response.
-		expect(result).toBeUndefined();
-	});
-
-	it('parses and returns output when the cron declares an output schema', async () => {
-		const cron = new CronBuilder()
-			.schedule('rate(1 day)')
-			.output(z.object({ cancelled: z.number() }))
-			.handle(async () => ({ cancelled: 3 }));
-
-		const adapter = new AWSScheduledFunction(envParser, cron);
-		const result = await adapter.handler(
-			scheduledEvent,
-			createMockContext(),
-			vi.fn(),
-		);
-
-		expect(result).toEqual({ cancelled: 3 });
-	});
-
-	it('exposes services to the cron handler', async () => {
-		let observed = 0;
-		const cron = new CronBuilder()
-			.schedule('rate(1 hour)')
-			.services([new CounterService()])
-			.handle(async ({ services }) => {
-				observed = services.counter.increment();
-			});
-
-		const adapter = new AWSScheduledFunction(envParser, cron);
-		await adapter.handler(scheduledEvent, createMockContext(), vi.fn());
-
-		expect(observed).toBe(1);
-	});
-
-	it('establishes request context so serviceContext.getLogger() works', async () => {
-		// The cron runs through the same runWithRequestContext wrapper as
-		// functions, so service code can resolve the request-scoped logger. We
-		// assert delegation via the cron's own logger rather than spying on the
-		// shared serviceContext proxy (which is a process-wide singleton).
-		let hadContext = false;
-		const logger = makeSpyLogger();
-
-		const cron = new CronBuilder()
-			.schedule('rate(1 day)')
-			.logger(logger)
-			.handle(async () => {
-				hadContext = serviceContext.hasContext();
-				serviceContext.getLogger().info('cron tick');
-			});
-
-		const adapter = new AWSScheduledFunction(envParser, cron);
-		await adapter.handler(scheduledEvent, createMockContext(), vi.fn());
-
-		expect(hadContext).toBe(true);
-		expect(logger.info).toHaveBeenCalledWith('cron tick');
-		// Context must not leak past the invocation.
-		expect(serviceContext.hasContext()).toBe(false);
-	});
-});