@geekmidas/constructs 9.0.2 → 10.0.0-alpha.1

package/src/functions/FunctionExecutionWrapper.ts

@@ -1,216 +0,0 @@
-import type { AuditableAction, Auditor, AuditStorage } from '@geekmidas/audit';
-import { DefaultAuditor } from '@geekmidas/audit';
-import { withAuditableTransaction } from '@geekmidas/audit/kysely';
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type {
-	ComposableStandardSchema,
-	InferComposableStandardSchema,
-	InferStandardSchema,
-} from '@geekmidas/schema';
-import {
-	type Service,
-	ServiceDiscovery,
-	type ServiceRecord,
-} from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { publishEvents } from '../publisher';
-import type { Function, FunctionHandler } from './Function';
-import { FunctionBuilder } from './FunctionBuilder';
-
-export abstract class FunctionExecutionWrapper<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TOutSchema extends StandardSchemaV1 | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TAuditStorage extends AuditStorage | undefined = undefined,
-	TAuditStorageServiceName extends string = string,
-	TDatabase = undefined,
-	TDatabaseServiceName extends string = string,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> {
-	constructor(
-		protected envParser: EnvironmentParser<{}>,
-		protected readonly fn: Function<
-			TInput,
-			TServices,
-			TLogger,
-			TOutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction,
-			FunctionHandler<
-				TInput,
-				TServices,
-				TLogger,
-				TOutSchema,
-				TDatabase,
-				TAuditStorage,
-				TAuditAction
-			>
-		>,
-	) {}
-
-	protected _logger?: TLogger;
-
-	get logger(): TLogger {
-		return this._logger || this.fn.logger;
-	}
-
-	get serviceDiscovery(): ServiceDiscovery<ServiceRecord<TServices>> {
-		const serviceDiscovery = ServiceDiscovery.getInstance<
-			ServiceRecord<TServices>
-		>(this.envParser);
-
-		return serviceDiscovery;
-	}
-
-	getServices(): Promise<ServiceRecord<TServices>> {
-		return this.serviceDiscovery.register(this.fn.services);
-	}
-
-	async getDatabase(): Promise<TDatabase | undefined> {
-		if (!this.fn.databaseService) {
-			return undefined;
-		}
-
-		const services = await this.serviceDiscovery.register([
-			this.fn.databaseService,
-		]);
-
-		return services[
-			this.fn.databaseService.serviceName as keyof typeof services
-		] as TDatabase;
-	}
-
-	/**
-	 * Get the audit storage service if configured.
-	 * Returns undefined if no auditor storage is configured.
-	 */
-	async getAuditStorage(): Promise<TAuditStorage | undefined> {
-		if (!this.fn.auditorStorageService) {
-			return undefined;
-		}
-
-		const services = await this.serviceDiscovery.register([
-			this.fn.auditorStorageService,
-		]);
-
-		return services[
-			this.fn.auditorStorageService.serviceName as keyof typeof services
-		] as TAuditStorage;
-	}
-
-	/**
-	 * Create an auditor instance for the function.
-	 * Returns undefined if no auditor storage is configured.
-	 */
-	async createAuditor(): Promise<Auditor<TAuditAction> | undefined> {
-		const storage = await this.getAuditStorage();
-		if (!storage) {
-			return undefined;
-		}
-
-		return new DefaultAuditor<TAuditAction>({
-			actor: { id: 'system', type: 'system' },
-			storage: storage as AuditStorage,
-			metadata: {
-				function: this.fn.type,
-			},
-		});
-	}
-
-	/**
-	 * Execute handler with audit transaction support.
-	 * If the audit storage has a database (via getDatabase()), wraps execution
-	 * in a transaction so audits are atomic with handler's database operations.
-	 *
-	 * @param handler - The handler function to execute (receives auditor and db)
-	 * @returns The handler result
-	 */
-	async executeWithAudit<T>(
-		handler: (ctx: {
-			auditor?: Auditor<TAuditAction>;
-			db?: TDatabase;
-		}) => Promise<T>,
-	): Promise<T> {
-		const auditor = await this.createAuditor();
-		const storage = await this.getAuditStorage();
-
-		// No audit context - just run handler with regular db
-		if (!auditor || !storage) {
-			const db = await this.getDatabase();
-			return handler({ db });
-		}
-
-		// Check if storage has a database and db service names match
-		const storageDb = (storage as AuditStorage).getDatabase?.();
-		const databaseServiceName = this.fn.databaseService?.serviceName;
-		const auditDbServiceName = this.fn.auditorStorageService?.serviceName;
-
-		// If the audit storage has a database and we're using the same database service
-		// (or the audit storage provides the database), use transactional execution
-		if (storageDb && databaseServiceName && auditDbServiceName) {
-			return withAuditableTransaction(
-				storageDb as any,
-				auditor as any,
-				async (trx) => {
-					// Use transaction as db
-					const response = await handler({
-						auditor,
-						db: trx as TDatabase,
-					});
-					// Audits are flushed by withAuditableTransaction before commit
-					return response;
-				},
-			);
-		}
-
-		// No database on storage or service names don't match - run handler and flush audits after
-		const db = await this.getDatabase();
-		const response = await handler({ auditor, db });
-
-		// Flush audits (no transaction)
-		await auditor.flush();
-
-		return response;
-	}
-
-	async getFunctionInput<TEvent>(
-		event: TEvent,
-	): Promise<InferComposableStandardSchema<TInput>> {
-		const parsedInput = await FunctionBuilder.parseComposableStandardSchema(
-			event,
-			this.fn.input,
-		);
-
-		return parsedInput as InferComposableStandardSchema<TInput>;
-	}
-
-	async publishEvents(response: InferStandardSchema<TOutSchema>) {
-		await publishEvents(
-			this.logger,
-			this.serviceDiscovery,
-			this.fn.events,
-			response,
-			this.fn.publisherService,
-		);
-	}
-
-	async parseComposableStandardSchema<T extends ComposableStandardSchema>(
-		data: unknown,
-		schema: T,
-	): Promise<InferComposableStandardSchema<T>> {
-		return FunctionBuilder.parseComposableStandardSchema(data, schema);
-	}
-}

package/src/functions/TestFunctionAdaptor.ts

@@ -1,217 +0,0 @@
-import type { AuditableAction, Auditor, AuditStorage } from '@geekmidas/audit';
-import { DefaultAuditor } from '@geekmidas/audit';
-import { EnvironmentParser } from '@geekmidas/envkit';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type {
-	ComposableStandardSchema,
-	InferComposableStandardSchema,
-	InferStandardSchema,
-} from '@geekmidas/schema';
-import {
-	runWithRequestContext,
-	type Service,
-	ServiceDiscovery,
-	type ServiceRecord,
-} from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { publishEvents } from '../publisher';
-import type { Function } from './Function';
-import { FunctionBuilder } from './FunctionBuilder';
-
-export class TestFunctionAdaptor<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TOutSchema extends StandardSchemaV1 | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TAuditStorage extends AuditStorage | undefined = undefined,
-	TAuditStorageServiceName extends string = string,
-	TDatabase = undefined,
-	TDatabaseServiceName extends string = string,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> {
-	static getDefaultServiceDiscovery<
-		TInput extends ComposableStandardSchema | undefined = undefined,
-		TOutSchema extends StandardSchemaV1 | undefined = undefined,
-		TServices extends Service[] = [],
-		TLogger extends Logger = Logger,
-		TEventPublisher extends EventPublisher<any> | undefined = undefined,
-		TEventPublisherServiceName extends string = string,
-		TAuditStorage extends AuditStorage | undefined = undefined,
-		TAuditStorageServiceName extends string = string,
-		TDatabase = undefined,
-		TDatabaseServiceName extends string = string,
-		TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-			string,
-			unknown
-		>,
-	>(
-		_fn: Function<
-			TInput,
-			TServices,
-			TLogger,
-			TOutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction,
-			any
-		>,
-	) {
-		return ServiceDiscovery.getInstance(new EnvironmentParser({}));
-	}
-
-	constructor(
-		private readonly fn: Function<
-			TInput,
-			TServices,
-			TLogger,
-			TOutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction,
-			any
-		>,
-		private serviceDiscovery: ServiceDiscovery<any> = TestFunctionAdaptor.getDefaultServiceDiscovery(
-			fn,
-		),
-	) {}
-
-	async invoke(
-		ctx: TestFunctionRequest<
-			TInput,
-			TServices,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TDatabase,
-			TAuditAction
-		>,
-	): Promise<InferStandardSchema<TOutSchema>> {
-		// Parse input if schema is provided
-
-		const parsedInput = await FunctionBuilder.parseComposableStandardSchema(
-			ctx.input,
-			this.fn.input,
-		);
-
-		// Create logger with context
-		const logger = this.fn.logger.child({
-			test: true,
-		}) as TLogger;
-
-		// Register services (use provided services or register from function)
-		let services: ServiceRecord<TServices>;
-		if (ctx.services) {
-			services = ctx.services;
-		} else {
-			services = await this.serviceDiscovery.register(this.fn.services);
-		}
-
-		// Resolve database (use provided db or register from function)
-		let db: TDatabase | undefined;
-		if ('db' in ctx && ctx.db !== undefined) {
-			db = ctx.db;
-		} else if (this.fn.databaseService) {
-			const dbServices = await this.serviceDiscovery.register([
-				this.fn.databaseService,
-			]);
-			db = dbServices[
-				this.fn.databaseService.serviceName as keyof typeof dbServices
-			] as TDatabase;
-		}
-
-		// Resolve auditor (use provided auditor or create from function)
-		let auditor: Auditor<TAuditAction> | undefined;
-		if ('auditor' in ctx && ctx.auditor !== undefined) {
-			auditor = ctx.auditor;
-		} else if (this.fn.auditorStorageService) {
-			const auditServices = await this.serviceDiscovery.register([
-				this.fn.auditorStorageService,
-			]);
-			const storage = auditServices[
-				this.fn.auditorStorageService.serviceName as keyof typeof auditServices
-			] as AuditStorage;
-
-			auditor = new DefaultAuditor<TAuditAction>({
-				actor: { id: 'system', type: 'system' },
-				storage,
-				metadata: {
-					function: this.fn.type,
-					test: true,
-				},
-			});
-		}
-
-		// Wrap execution in request context for service access via context.getLogger()
-		const requestId = `test-${Date.now()}`;
-		const startTime = Date.now();
-
-		return runWithRequestContext({ logger, requestId, startTime }, async () => {
-			// Execute the function
-			const response = await this.fn.fn({
-				input: parsedInput,
-				services,
-				logger,
-				db,
-				auditor,
-			} as any);
-
-			// Parse output if schema is provided
-			const output = await this.fn.parseOutput(response);
-
-			// Flush audits if any were recorded
-			if (auditor) {
-				const records = auditor.getRecords();
-				if (records.length > 0) {
-					logger.debug(
-						{ auditCount: records.length },
-						'Flushing function audits',
-					);
-					await auditor.flush();
-				}
-			}
-
-			// Register publisher service if provided in context
-
-			await publishEvents(
-				logger,
-				this.serviceDiscovery,
-				this.fn.events,
-				output,
-				this.fn.publisherService,
-			);
-
-			return output;
-		}) as Promise<InferStandardSchema<TOutSchema>>;
-	}
-}
-
-export type TestFunctionRequest<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TServices extends Service[] = [],
-	TEventPublisher extends EventPublisher<any> | undefined = undefined,
-	TEventPublisherServiceName extends string = string,
-	TDatabase = undefined,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> = {
-	input: InferComposableStandardSchema<TInput>;
-	services: ServiceRecord<TServices>;
-	publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
-	db?: TDatabase;
-	auditor?: Auditor<TAuditAction>;
-} & InferComposableStandardSchema<{ input: TInput }>;