@geekmidas/constructs 9.0.2 → 10.0.0-alpha.0

package/src/functions/Function.ts

@@ -1,238 +0,0 @@
-import type { AuditableAction, Auditor, AuditStorage } from '@geekmidas/audit';
-import { UnprocessableEntityError } from '@geekmidas/errors';
-import type { EventPublisher, MappedEvent } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type {
-	ComposableStandardSchema,
-	InferComposableStandardSchema,
-	InferStandardSchema,
-} from '@geekmidas/schema';
-import { parseSchema } from '@geekmidas/schema/parser';
-import type { Service, ServiceRecord } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import uniqBy from 'lodash.uniqby';
-import { Construct, ConstructType } from '../Construct';
-
-const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
-export class FunctionFactory<
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-> {
-	private defaultServices: TServices;
-	constructor(
-		defaultServices: TServices,
-		private defaultLogger: TLogger = DEFAULT_LOGGER,
-	) {
-		// Initialize default services
-		this.defaultServices = uniqBy(
-			defaultServices,
-			(s) => s.serviceName,
-		) as TServices;
-	}
-
-	// Create a new factory with services
-	services<S extends Service[]>(
-		services: S,
-	): FunctionFactory<[...S, ...TServices], TLogger> {
-		return new FunctionFactory<[...S, ...TServices], TLogger>(
-			[...services, ...this.defaultServices],
-			this.defaultLogger,
-		);
-	}
-
-	logger<L extends Logger>(logger: L): FunctionFactory<TServices, L> {
-		return new FunctionFactory<TServices, L>(this.defaultServices, logger);
-	}
-}
-
-export class Function<
-	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,
-	TAuditStorage extends AuditStorage | undefined = undefined,
-	TAuditStorageServiceName extends string = string,
-	TDatabase = undefined,
-	TDatabaseServiceName extends string = string,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-	Fn extends FunctionHandler<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TDatabase,
-		TAuditStorage,
-		TAuditAction
-	> = FunctionHandler<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TDatabase,
-		TAuditStorage,
-		TAuditAction
-	>,
-> extends Construct<
-	TLogger,
-	TEventPublisherServiceName,
-	TEventPublisher,
-	OutSchema,
-	TServices,
-	TAuditStorageServiceName,
-	TAuditStorage
-> {
-	__IS_FUNCTION__ = true;
-
-	static isFunction(obj: any): obj is Function<any, any, any, any, any> {
-		return Boolean(
-			obj &&
-				obj.__IS_FUNCTION__ === true &&
-				obj.type === ConstructType.Function,
-		);
-	}
-
-	/**
-	 * Validates data against a StandardSchema.
-	 *
-	 * @param schema - The StandardSchema to validate against
-	 * @param data - The data to validate
-	 * @returns Validation result with value or issues
-	 */
-	static validate<T extends StandardSchemaV1>(schema: T, data: unknown) {
-		return schema['~standard'].validate(data);
-	}
-
-	/**
-	 * Parses and validates data against a schema, throwing an error if validation fails.
-	 *
-	 * @param schema - The StandardSchema to validate against
-	 * @param data - The data to parse and validate
-	 * @returns The validated data with proper typing
-	 * @throws {UnprocessableEntityError} When validation fails
-	 */
-	static async parseSchema<T extends StandardSchemaV1>(
-		schema: T,
-		data: unknown,
-	): Promise<InferStandardSchema<T>> {
-		try {
-			return await parseSchema(schema, data);
-		} catch (issues) {
-			throw new UnprocessableEntityError('Validation failed', issues);
-		}
-	}
-
-	/**
-	 * Parses and validates the endpoint output against the output schema.
-	 *
-	 * @param output - The raw output data to validate
-	 * @returns The validated output data
-	 * @throws {UnprocessableEntityError} When output validation fails
-	 */
-	async parseOutput(output: unknown): Promise<InferStandardSchema<OutSchema>> {
-		return Function.parseSchema(
-			this.outputSchema as StandardSchemaV1,
-			output,
-		) as Promise<InferStandardSchema<OutSchema>>;
-	}
-
-	constructor(
-		public readonly fn: Fn,
-		timeout = 30000, // Default timeout of 30 seconds
-		type: ConstructType = ConstructType.Function,
-		public input?: TInput,
-		outputSchema?: OutSchema,
-		services: TServices = [] as unknown as TServices,
-		logger: TLogger = DEFAULT_LOGGER,
-		publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
-		events: MappedEvent<TEventPublisher, OutSchema>[] = [],
-		memorySize?: number,
-		auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
-		public override databaseService?: Service<TDatabaseServiceName, TDatabase>,
-	) {
-		super(
-			type,
-			logger,
-			services,
-			events,
-			publisherService,
-			outputSchema,
-			timeout,
-			memorySize,
-			auditorStorageService,
-		);
-	}
-}
-
-export type FunctionHandler<
-	TInput extends ComposableStandardSchema | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TDatabase = undefined,
-	TAuditStorage extends AuditStorage | undefined = undefined,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> = (
-	ctx: FunctionContext<
-		TInput,
-		TServices,
-		TLogger,
-		TDatabase,
-		TAuditStorage,
-		TAuditAction
-	>,
-) => OutSchema extends StandardSchemaV1
-	? InferStandardSchema<OutSchema> | Promise<InferStandardSchema<OutSchema>>
-	: any | Promise<any>;
-
-/**
- * Conditional type that adds `db` property only when TDatabase is configured.
- */
-type DatabaseContext<TDatabase> = TDatabase extends undefined
-	? {}
-	: { db: TDatabase };
-
-/**
- * Conditional auditor context - only present when audit storage is configured.
- */
-type AuditorContext<
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-	TAuditStorage = undefined,
-> = TAuditStorage extends undefined
-	? {}
-	: {
-			/**
-			 * Auditor instance for recording audit events.
-			 * Only present when audit storage is configured on the function.
-			 */
-			auditor: Auditor<TAuditAction>;
-		};
-
-export type FunctionContext<
-	Input extends ComposableStandardSchema | undefined = undefined,
-	TServices extends Service[] = [],
-	TLogger extends Logger = Logger,
-	TDatabase = undefined,
-	TAuditStorage extends AuditStorage | undefined = undefined,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> = {
-	services: ServiceRecord<TServices>;
-	logger: TLogger;
-	input: InferComposableStandardSchema<Input>;
-} & DatabaseContext<TDatabase> &
-	AuditorContext<TAuditAction, TAuditStorage>;

package/src/functions/FunctionBuilder.ts

@@ -1,391 +0,0 @@
-import type { AuditableAction, AuditStorage } from '@geekmidas/audit';
-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 { BaseFunctionBuilder } from './BaseFunctionBuilder';
-import { Function, type FunctionHandler } from './Function';
-
-const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
-export class FunctionBuilder<
-	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,
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> extends BaseFunctionBuilder<
-	TInput,
-	OutSchema,
-	TServices,
-	TLogger,
-	TEventPublisher,
-	TEventPublisherServiceName,
-	TAuditStorage,
-	TAuditStorageServiceName,
-	TDatabase,
-	TDatabaseServiceName
-> {
-	protected _memorySize?: number;
-
-	constructor(public override type = ConstructType.Function) {
-		super(type);
-	}
-
-	override timeout(timeout: number): this {
-		this._timeout = timeout;
-		return this;
-	}
-
-	memorySize(memorySize: number): this {
-		this._memorySize = memorySize;
-		return this;
-	}
-
-	output<T extends StandardSchemaV1>(
-		schema: T,
-	): FunctionBuilder<
-		TInput,
-		T,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this.outputSchema = schema as unknown as OutSchema;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			T,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	input<T extends ComposableStandardSchema>(
-		schema: T,
-	): FunctionBuilder<
-		T,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this.inputSchema = schema as unknown as TInput;
-
-		return this as unknown as FunctionBuilder<
-			T,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	services<T extends Service[]>(
-		services: T,
-	): FunctionBuilder<
-		TInput,
-		OutSchema,
-		[...TServices, ...T],
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this._services = uniqBy(
-			[...this._services, ...services],
-			(s) => s.serviceName,
-		) as TServices;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			[...TServices, ...T],
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	logger<T extends Logger>(
-		logger: T,
-	): FunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		T,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this._logger = logger as unknown as TLogger;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			T,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	override publisher<T extends EventPublisher<any>, TName extends string>(
-		publisher: Service<TName, T>,
-	): FunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		T,
-		TName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this._publisher = publisher as unknown as Service<
-			TEventPublisherServiceName,
-			TEventPublisher
-		>;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			T,
-			TName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	override auditor<T extends AuditStorage, TName extends string>(
-		storage: Service<TName, T>,
-	): FunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		T,
-		TName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction
-	> {
-		this._auditorStorage = storage as unknown as Service<
-			TAuditStorageServiceName,
-			TAuditStorage
-		>;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			T,
-			TName,
-			TDatabase,
-			TDatabaseServiceName,
-			TAuditAction
-		>;
-	}
-
-	/**
-	 * Set the audit action types for this function.
-	 * This provides type-safety for the auditor in the handler context.
-	 */
-	actions<T extends AuditableAction<string, unknown>>(): FunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		T
-	> {
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			TDatabase,
-			TDatabaseServiceName,
-			T
-		>;
-	}
-
-	/**
-	 * Set the database service for this function.
-	 * The database will be available in the handler context as `db`.
-	 */
-	override database<T, TName extends string>(
-		service: Service<TName, T>,
-	): FunctionBuilder<
-		TInput,
-		OutSchema,
-		TServices,
-		TLogger,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		T,
-		TName,
-		TAuditAction
-	> {
-		this._databaseService = service as unknown as Service<
-			TDatabaseServiceName,
-			TDatabase
-		>;
-
-		return this as unknown as FunctionBuilder<
-			TInput,
-			OutSchema,
-			TServices,
-			TLogger,
-			TEventPublisher,
-			TEventPublisherServiceName,
-			TAuditStorage,
-			TAuditStorageServiceName,
-			T,
-			TName,
-			TAuditAction
-		>;
-	}
-
-	handle(
-		fn: FunctionHandler<
-			TInput,
-			TServices,
-			TLogger,
-			OutSchema,
-			TDatabase,
-			TAuditStorage,
-			TAuditAction
-		>,
-	): Function<
-		TInput,
-		TServices,
-		TLogger,
-		OutSchema,
-		TEventPublisher,
-		TEventPublisherServiceName,
-		TAuditStorage,
-		TAuditStorageServiceName,
-		TDatabase,
-		TDatabaseServiceName,
-		TAuditAction,
-		FunctionHandler<
-			TInput,
-			TServices,
-			TLogger,
-			OutSchema,
-			TDatabase,
-			TAuditStorage,
-			TAuditAction
-		>
-	> {
-		const func = new Function(
-			fn,
-			this._timeout,
-			this.type,
-			this.inputSchema,
-			this.outputSchema,
-			this._services,
-			this._logger,
-			this._publisher,
-			this._events,
-			this._memorySize,
-			this._auditorStorage,
-			this._databaseService,
-		);
-
-		// Reset builder state after creating the function to prevent pollution
-		this._services = [] as Service[] as TServices;
-		this._logger = DEFAULT_LOGGER;
-		this._events = [];
-		this._publisher = undefined;
-		this._auditorStorage = undefined;
-		this._databaseService = undefined;
-		this.inputSchema = undefined;
-		this.outputSchema = undefined;
-		this._timeout = undefined;
-		this._memorySize = undefined;
-
-		return func;
-	}
-}