@geekmidas/constructs 9.0.2 → 10.0.0-alpha.1

package/src/functions/AWSLambdaFunction.ts

@@ -1,348 +0,0 @@
-import type { AuditableAction, Auditor, AuditStorage } from '@geekmidas/audit';
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import { wrapError } from '@geekmidas/errors';
-import type { EventPublisher } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type {
-	ComposableStandardSchema,
-	InferComposableStandardSchema,
-	InferStandardSchema,
-} from '@geekmidas/schema';
-import type { Service, ServiceRecord } from '@geekmidas/services';
-import { runWithRequestContext } from '@geekmidas/services';
-import middy, { type MiddlewareObj } from '@middy/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Context, Handler } from 'aws-lambda';
-import type { Function, FunctionHandler } from './Function';
-import { FunctionBuilder } from './FunctionBuilder';
-import { FunctionExecutionWrapper } from './FunctionExecutionWrapper';
-
-export type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<
-	TEvent,
-	TResult
->;
-
-type FunctionEvent<
-	TEvent,
-	TInput extends ComposableStandardSchema | undefined,
-	TServices extends Service[],
-	TLogger extends Logger,
-	TDatabase = undefined,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> = TEvent & {
-	parsedInput: InferComposableStandardSchema<TInput>;
-	services: ServiceRecord<TServices>;
-	logger: TLogger;
-	db: TDatabase | undefined;
-	auditor: Auditor<TAuditAction> | undefined;
-};
-
-type Middleware<
-	TEvent,
-	TInput extends ComposableStandardSchema | undefined,
-	TServices extends Service[],
-	TLogger extends Logger,
-	TOutSchema extends StandardSchemaV1 | undefined,
-	TDatabase = undefined,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> = MiddlewareObj<
-	FunctionEvent<TEvent, TInput, TServices, TLogger, TDatabase, TAuditAction>,
-	InferComposableStandardSchema<TOutSchema>,
-	Error,
-	Context
->;
-
-export class AWSLambdaFunction<
-	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
-	>,
-> extends FunctionExecutionWrapper<
-	TInput,
-	TOutSchema,
-	TServices,
-	TLogger,
-	TEventPublisher,
-	TEventPublisherServiceName,
-	TAuditStorage,
-	TAuditStorageServiceName,
-	TDatabase,
-	TDatabaseServiceName,
-	TAuditAction
-> {
-	constructor(
-		envParser: EnvironmentParser<{}>,
-		override readonly fn: Function<
-			TInput,
-			TServices,
-			TLogger,
-			TOutSchema,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction,
-			FunctionHandler<
-				TInput,
-				TServices,
-				TLogger,
-				TOutSchema,
-				TDatabase,
-				TAuditStorage,
-				TAuditAction
-			>
-		>,
-	) {
-		super(envParser, fn);
-	}
-
-	private error<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			onError: (req) => {
-				const logger = req.event?.logger || this.fn.logger;
-				logger.error(req.error || {}, 'Error processing function');
-
-				// Re-throw the wrapped error to let Lambda handle it
-				throw wrapError(req.error);
-			},
-		};
-	}
-
-	private baseInput<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: (_req) => {},
-		};
-	}
-
-	private input<
-		TEvent extends { input: InferComposableStandardSchema<TInput> },
-	>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: async (req) => {
-				try {
-					// Parse input if schema is provided
-					if (this.fn.input) {
-						const parsedInput =
-							await FunctionBuilder.parseComposableStandardSchema(
-								req.event,
-								this.fn.input,
-							);
-
-						req.event.parsedInput =
-							parsedInput as InferComposableStandardSchema<TInput>;
-					} else {
-						// If no schema, pass the event as-is
-						req.event.parsedInput = req.event as any;
-					}
-				} catch (error) {
-					this.logger.error(
-						{ error, event: req.event },
-						'Failed to parse input',
-					);
-					throw error;
-				}
-			},
-		};
-	}
-
-	private loggerMiddleware<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: (req) => {
-				this._logger = this.fn.logger.child({
-					fn: {
-						name: req.context.functionName,
-						version: req.context.functionVersion,
-						memory: req.context.memoryLimitInMB,
-					},
-					req: {
-						id: req.context.awsRequestId,
-					},
-				}) as TLogger;
-
-				req.event.logger = this._logger;
-			},
-		};
-	}
-
-	private services<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: async (req) => {
-				req.event.services = await this.getServices();
-			},
-		};
-	}
-
-	private database<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: async (req) => {
-				req.event.db = await this.getDatabase();
-			},
-		};
-	}
-
-	private auditor<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			before: async (req) => {
-				req.event.auditor = await this.createAuditor();
-			},
-			after: async (req) => {
-				// Flush any pending audits after successful execution
-				if (req.event.auditor) {
-					const records = req.event.auditor.getRecords();
-					if (records.length > 0) {
-						this.logger.debug(
-							{ auditCount: records.length },
-							'Flushing function audits',
-						);
-						await req.event.auditor.flush();
-					}
-				}
-			},
-		};
-	}
-
-	private events<TEvent>(): Middleware<
-		TEvent,
-		TInput,
-		TServices,
-		TLogger,
-		TOutSchema,
-		TDatabase,
-		TAuditAction
-	> {
-		return {
-			after: async (req) => {
-				const response = (req.response ||
-					undefined) as InferStandardSchema<TOutSchema>;
-				await this.publishEvents(response);
-			},
-		};
-	}
-
-	private async _handler<TEvent>(
-		event: FunctionEvent<
-			TEvent,
-			TInput,
-			TServices,
-			TLogger,
-			TDatabase,
-			TAuditAction
-		>,
-	) {
-		// Execute the function with the parsed context
-		const result = await this.fn.fn({
-			input: event.parsedInput,
-			services: event.services,
-			logger: event.logger,
-			db: event.db,
-			auditor: event.auditor,
-		} as any);
-
-		// Parse output if schema is provided
-		const output = await this.fn.parseOutput(result);
-
-		return output;
-	}
-
-	get handler(): AWSLambdaHandler {
-		const handler = this._handler.bind(this);
-
-		// Apply middleware in order
-		const chain = middy(handler)
-			.use(this.loggerMiddleware())
-			.use(this.baseInput())
-			.use(this.error())
-			.use(this.services())
-			.use(this.database())
-			.use(this.auditor())
-			.use(this.input())
-			.use(this.events());
-
-		// Wrap entire Middy chain in request context for service access
-		const wrappedHandler = async (event: unknown, context: Context) => {
-			const startTime = Date.now();
-			const requestId = context.awsRequestId;
-			const logger = this.fn.logger.child({ requestId }) as TLogger;
-
-			return runWithRequestContext({ logger, requestId, startTime }, () =>
-				chain(event as Parameters<typeof chain>[0], context),
-			);
-		};
-
-		return wrappedHandler as unknown as AWSLambdaHandler;
-	}
-}

package/src/functions/BaseFunctionBuilder.ts

@@ -1,201 +0,0 @@
-import type { AuditStorage } from '@geekmidas/audit';
-import type { EventPublisher, MappedEvent } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type {
-	ComposableStandardSchema,
-	InferComposableStandardSchema,
-} from '@geekmidas/schema';
-import type { Service } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import get from 'lodash.get';
-import { ConstructType } from '../Construct';
-
-const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
-export abstract class BaseFunctionBuilder<
-	TInput extends ComposableStandardSchema,
-	OutSchema 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,
-> {
-	protected inputSchema?: TInput;
-	protected outputSchema?: OutSchema;
-	protected _timeout?: number;
-
-	public _services: TServices = [] as Service[] as TServices;
-	public _logger: TLogger = DEFAULT_LOGGER;
-
-	protected _events: MappedEvent<TEventPublisher, OutSchema>[] = [];
-	protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
-	protected _auditorStorage?: Service<TAuditStorageServiceName, TAuditStorage>;
-	protected _databaseService?: Service<TDatabaseServiceName, TDatabase>;
-
-	static isStandardSchemaV1(s: unknown): s is StandardSchemaV1 {
-		const schema = (s as StandardSchemaV1)['~standard'];
-
-		return schema && typeof schema.validate === 'function';
-	}
-
-	static async parseComposableStandardSchema<
-		T extends ComposableStandardSchema | undefined,
-	>(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>> {
-		if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {
-			const validated = await schema['~standard'].validate(data);
-
-			if (validated.issues) {
-				throw validated.issues;
-			}
-
-			return validated.value as InferComposableStandardSchema<T>;
-		}
-
-		const result: any = {};
-		for (const key in schema) {
-			const item = schema[key];
-			if (BaseFunctionBuilder.isStandardSchemaV1(item)) {
-				const value = get(data, key);
-				const validated = await item['~standard'].validate(value);
-
-				if (validated.issues) {
-					throw validated.issues;
-				}
-
-				result[key] = validated.value;
-			}
-		}
-
-		return result as InferComposableStandardSchema<T>;
-	}
-
-	constructor(public type = ConstructType.Function) {}
-
-	abstract services<T extends Service[]>(services: T): any;
-
-	abstract logger<T extends Logger>(logger: T): any;
-
-	timeout(timeout: number): this {
-		this._timeout = timeout;
-		return this;
-	}
-
-	abstract output<T extends StandardSchemaV1>(schema: T): any;
-
-	abstract input<T extends ComposableStandardSchema>(schema: T): any;
-
-	event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(
-		event: TEvent,
-	): this {
-		this._events.push(event);
-		return this;
-	}
-
-	publisher<T extends EventPublisher<any>, TName extends string>(
-		publisher: Service<TName, T>,
-	): BaseFunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		T,
-		TName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._publisher = publisher as unknown as Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>;
-
-		return this as unknown as BaseFunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			T,
-			TName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	auditor<T extends AuditStorage, TName extends string>(
-		storage: Service<TName, T>,
-	): BaseFunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		T,
-		TName,
-		TDatabase,
-		TDatabaseServiceName
-	> {
-		this._auditorStorage = storage as unknown as Service<
-			TAuditStorageServiceName,
-			TAuditStorage
-		>;
-
-		return this as unknown as BaseFunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			T,
-			TName,
-			TDatabase,
-			TDatabaseServiceName
-		>;
-	}
-
-	/**
-	 * Set the database service for this function.
-	 * The database will be available in the handler context as `db`.
-	 */
-	database<T, TName extends string>(
-		service: Service<TName, T>,
-	): BaseFunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		T,
-		TName
-	> {
-		this._databaseService = service as unknown as Service<
-			TDatabaseServiceName,
-			TDatabase
-		>;
-
-		return this as unknown as BaseFunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			T,
-			TName
-		>;
-	}
-}