@geekmidas/constructs 9.0.2 → 10.0.0-alpha.1

package/src/functions/__tests__/Function.spec.ts

@@ -1,477 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import { createMockContext } from '@geekmidas/testkit/aws';
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { ConstructType } from '../../Construct';
-import { AWSLambdaFunction } from '../AWSLambdaFunction';
-import { Function, FunctionFactory, type FunctionHandler } from '../Function';
-import { FunctionBuilder } from '../FunctionBuilder';
-import { TestFunctionAdaptor } from '../TestFunctionAdaptor';
-
-// Mock service for testing
-class TestService implements Service<'TestService', TestService> {
-	serviceName = 'TestService' as const;
-	static serviceName = 'TestService';
-
-	async register() {
-		return this;
-	}
-}
-
-class AnotherTestService
-	implements Service<'AnotherTestService', AnotherTestService>
-{
-	serviceName = 'AnotherTestService' as const;
-	static serviceName = 'AnotherTestService';
-
-	async register() {
-		return this;
-	}
-}
-
-describe('Function', () => {
-	describe('FunctionFactory', () => {
-		it('should create a function factory with default services', () => {
-			const service1 = new TestService();
-			const service2 = new AnotherTestService();
-			const factory = new FunctionFactory([service1, service2]);
-
-			expect(factory).toBeDefined();
-		});
-
-		it('should deduplicate services by name', () => {
-			const service1 = new TestService();
-			const service2 = new TestService(); // Duplicate
-			const service3 = new AnotherTestService();
-
-			const factory = new FunctionFactory([service1, service2, service3]);
-			// Internal defaultServices should have only 2 unique services
-			expect(factory.defaultServices.length).toBe(2);
-		});
-
-		it('should add services using services() method', () => {
-			const service1 = new TestService();
-			const factory = new FunctionFactory([]);
-
-			const newFactory = factory.services([service1]);
-			expect(newFactory).toBeDefined();
-			expect(newFactory.defaultServices.length).toBe(1);
-		});
-
-		it('should merge services when chaining services() calls', () => {
-			const service1 = new TestService();
-			const service2 = new AnotherTestService();
-			const factory = new FunctionFactory([service1]);
-
-			const newFactory = factory.services([service2]);
-			expect(newFactory.defaultServices.length).toBe(2);
-		});
-
-		it('should set custom logger using logger() method', () => {
-			const customLogger = new ConsoleLogger();
-			const factory = new FunctionFactory([]);
-
-			const newFactory = factory.logger(customLogger);
-			expect(newFactory.defaultLogger).toBe(customLogger);
-		});
-	});
-
-	describe('Function class', () => {
-		it('should create a function instance', () => {
-			const handler: FunctionHandler = async () => {
-				return { result: 'success' };
-			};
-
-			const fn = new Function(handler);
-			expect(fn).toBeDefined();
-			expect(fn.__IS_FUNCTION__).toBe(true);
-			expect(fn.timeout).toBe(30000); // Default timeout
-			expect(fn.type).toBe(ConstructType.Function);
-		});
-
-		it('should create a function with custom timeout', () => {
-			const handler: FunctionHandler = async () => ({ result: 'success' });
-			const fn = new Function(handler, 60000);
-
-			expect(fn.timeout).toBe(60000);
-		});
-
-		it('should create a function with input and output schemas', () => {
-			const inputSchema = z.object({ name: z.string() });
-			const outputSchema = z.object({ message: z.string() });
-			const handler: FunctionHandler = async () => ({ message: 'Hello' });
-
-			const fn = new Function(
-				handler,
-				30000,
-				ConstructType.Function,
-				inputSchema,
-				outputSchema,
-			);
-
-			expect(fn.input).toBe(inputSchema);
-			expect(fn.outputSchema).toBe(outputSchema);
-		});
-
-		it('should detect function instances using isFunction', () => {
-			const handler: FunctionHandler = async () => ({ result: 'success' });
-			const fn = new Function(handler);
-
-			expect(Function.isFunction(fn)).toBe(true);
-			expect(Function.isFunction({})).toBeFalsy();
-			expect(Function.isFunction(null)).toBeFalsy();
-			expect(Function.isFunction(undefined)).toBeFalsy();
-			expect(Function.isFunction({ __IS_FUNCTION__: false })).toBe(false);
-			expect(Function.isFunction({ __IS_FUNCTION__: true })).toBe(false);
-		});
-	});
-
-	describe('FunctionBuilder', () => {
-		describe('isStandardSchemaV1', () => {
-			it('should identify standard schema v1', () => {
-				const zodSchema = z.string();
-				expect(FunctionBuilder.isStandardSchemaV1(zodSchema)).toBe(true);
-			});
-
-			it('should return false for non-standard schemas', () => {
-				expect(FunctionBuilder.isStandardSchemaV1({})).toBeFalsy();
-				expect(FunctionBuilder.isStandardSchemaV1('string')).toBeFalsy();
-				expect(FunctionBuilder.isStandardSchemaV1(123)).toBeFalsy();
-				expect(FunctionBuilder.isStandardSchemaV1(true)).toBeFalsy();
-				expect(
-					FunctionBuilder.isStandardSchemaV1({ '~standard': {} }),
-				).toBeFalsy();
-				expect(
-					FunctionBuilder.isStandardSchemaV1({
-						'~standard': { validate: 'not a function' },
-					}),
-				).toBeFalsy();
-			});
-		});
-
-		describe('parseComposableStandardSchema', () => {
-			it('should parse standard schema', async () => {
-				const schema = z.object({
-					name: z.string(),
-					age: z.number().optional(),
-				});
-
-				const data = { name: 'John', age: 30 };
-				const result = await FunctionBuilder.parseComposableStandardSchema(
-					data,
-					schema,
-				);
-				expect(result).toEqual({ name: 'John', age: 30 });
-			});
-
-			it('should parse composed schema', async () => {
-				const schema = {
-					name: z.string(),
-					age: z.number().optional(),
-				};
-
-				const data = { name: 'John', age: 30 };
-				const result = await FunctionBuilder.parseComposableStandardSchema(
-					data,
-					schema,
-				);
-				expect(result).toEqual({ name: 'John', age: 30 });
-			});
-
-			it('should throw validation errors for invalid data', async () => {
-				const schema = z.object({
-					name: z.string(),
-					age: z.number(),
-				});
-
-				const invalidData = { name: 'John', age: 'not a number' };
-				await expect(
-					FunctionBuilder.parseComposableStandardSchema(invalidData, schema),
-				).rejects.toThrow();
-			});
-
-			it('should throw validation errors for composed schema with invalid data', async () => {
-				const schema = {
-					name: z.string(),
-					email: z.string().email(),
-				};
-
-				const invalidData = { name: 'John', email: 'invalid-email' };
-				await expect(
-					FunctionBuilder.parseComposableStandardSchema(invalidData, schema),
-				).rejects.toThrow();
-			});
-
-			it('should handle nested paths in composed schemas', async () => {
-				const schema = {
-					'user.name': z.string(),
-					'user.email': z.string().email(),
-				};
-
-				const data = {
-					user: {
-						name: 'John',
-						email: 'john@example.com',
-					},
-				};
-
-				const result = await FunctionBuilder.parseComposableStandardSchema(
-					data,
-					schema,
-				);
-				expect(result).toEqual({
-					'user.name': 'John',
-					'user.email': 'john@example.com',
-				});
-			});
-		});
-
-		describe('builder methods', () => {
-			it('should create a builder with default type', () => {
-				const builder = new FunctionBuilder();
-				expect(builder.type).toBe(ConstructType.Function);
-			});
-
-			it('should add services', () => {
-				const service = new TestService();
-				const builder = new FunctionBuilder().services([service]);
-
-				expect(builder._services.length).toBe(1);
-				expect(builder._services[0]).toBe(service);
-			});
-
-			it('should deduplicate services when adding', () => {
-				const builder = new FunctionBuilder();
-				const service1 = new TestService();
-				const service2 = new TestService(); // Same service name
-
-				const newBuilder = builder.services([service1, service2]);
-				expect(newBuilder._services.length).toBe(1);
-			});
-
-			it('should set logger', () => {
-				const builder = new FunctionBuilder();
-				const customLogger = new ConsoleLogger();
-
-				const newBuilder = builder.logger(customLogger);
-				expect(newBuilder._logger).toBe(customLogger);
-			});
-
-			it('should set timeout', () => {
-				const builder = new FunctionBuilder();
-				const newBuilder = builder.timeout(60000);
-
-				// We can't access _timeout directly as it's protected
-				// But we can verify the method returns the builder for chaining
-				expect(newBuilder).toBeInstanceOf(FunctionBuilder);
-			});
-
-			it('should set output schema', () => {
-				const builder = new FunctionBuilder();
-				const outputSchema = z.object({ result: z.string() });
-
-				const newBuilder = builder.output(outputSchema);
-				expect(newBuilder.outputSchema).toBe(outputSchema);
-			});
-
-			it('should set input schema', () => {
-				const builder = new FunctionBuilder();
-				const inputSchema = z.object({ data: z.string() });
-
-				const newBuilder = builder.input(inputSchema);
-				expect(newBuilder.inputSchema).toBe(inputSchema);
-			});
-
-			it('should chain multiple builder methods', () => {
-				const builder = new FunctionBuilder();
-				const service = new TestService();
-				const logger = new ConsoleLogger();
-				const inputSchema = z.object({ data: z.string() });
-				const outputSchema = z.object({ result: z.string() });
-
-				const finalBuilder = builder
-					.services([service])
-					.logger(logger)
-					.timeout(45000)
-					.input(inputSchema)
-					.output(outputSchema);
-
-				expect(finalBuilder._services.length).toBe(1);
-				expect(finalBuilder._logger).toBe(logger);
-				// _timeout is protected, so we just verify the builder chain works
-				expect(finalBuilder).toBeInstanceOf(FunctionBuilder);
-			});
-
-			it('should set database service', () => {
-				const builder = new FunctionBuilder();
-
-				class MockDatabase {
-					async query(_sql: string) {
-						return [];
-					}
-				}
-
-				const databaseService = {
-					serviceName: 'database' as const,
-					async register() {
-						return new MockDatabase();
-					},
-				};
-
-				const newBuilder = builder.database(databaseService);
-				expect(newBuilder._databaseService).toBe(databaseService);
-			});
-
-			it('should chain database with other methods', () => {
-				const builder = new FunctionBuilder();
-				const service = new TestService();
-				const logger = new ConsoleLogger();
-
-				class MockDatabase {
-					async query(_sql: string) {
-						return [];
-					}
-				}
-
-				const databaseService = {
-					serviceName: 'database' as const,
-					async register() {
-						return new MockDatabase();
-					},
-				};
-
-				const finalBuilder = builder
-					.services([service])
-					.logger(logger)
-					.database(databaseService)
-					.output(z.object({ result: z.string() }));
-
-				expect(finalBuilder._services.length).toBe(1);
-				expect(finalBuilder._databaseService).toBe(databaseService);
-				expect(finalBuilder).toBeInstanceOf(FunctionBuilder);
-			});
-
-			it('should create function with database service', () => {
-				const builder = new FunctionBuilder();
-
-				class MockDatabase {
-					async query(_sql: string) {
-						return [];
-					}
-				}
-
-				const databaseService = {
-					serviceName: 'database' as const,
-					async register() {
-						return new MockDatabase();
-					},
-				};
-
-				const fn = builder
-					.database(databaseService)
-					.output(z.object({ result: z.string() }))
-					.handle(async ({ db }) => {
-						// db should be available
-						return { result: 'success' };
-					});
-
-				expect(fn.databaseService).toBe(databaseService);
-			});
-		});
-	});
-
-	describe('FunctionHandler type', () => {
-		it('should handle function with full context', async () => {
-			const handler: FunctionHandler<
-				{ name: z.ZodString },
-				[TestService],
-				ConsoleLogger,
-				z.ZodObject<{ message: z.ZodString }>
-			> = async ({ services, logger, input }) => {
-				expect(services).toBeDefined();
-				expect(logger).toBeDefined();
-				expect(input).toBeDefined();
-				return { message: `Hello ${input.name}` };
-			};
-
-			const result = await handler({
-				services: { TestService: new TestService() },
-				logger: new ConsoleLogger(),
-				input: {
-					name: 'John',
-				},
-			});
-
-			expect(result).toEqual({ message: 'Hello John' });
-		});
-	});
-
-	describe('Function Adaptors Integration', () => {
-		describe('TestFunctionAdaptor', () => {
-			it('should work with TestFunctionAdaptor for testing', async () => {
-				const inputSchema = z.object({ name: z.string() });
-				const outputSchema = z.object({ greeting: z.string() });
-
-				const fn = new Function(
-					async ({ input }) => ({
-						greeting: `Hello ${input.name}!`,
-					}),
-					undefined,
-					undefined,
-					inputSchema,
-					outputSchema,
-					[],
-				);
-
-				const adaptor = new TestFunctionAdaptor(fn);
-
-				const result = await adaptor.invoke({
-					services: {},
-					input: { name: 'Integration Test' },
-				});
-
-				expect(result).toEqual({
-					greeting: 'Hello Integration Test!',
-				});
-			});
-		});
-
-		describe('AWSLambdaFunction', () => {
-			it('should work with AWSLambdaFunction for AWS Lambda', async () => {
-				const inputSchema = { message: z.string() };
-				const outputSchema = z.object({ processed: z.string() });
-
-				const fn = new Function(
-					async ({ logger, ...rest }) => {
-						logger.info('Processing message');
-						return { processed: `Processed: ${rest.input.message}` };
-					},
-					undefined,
-					undefined,
-					inputSchema,
-					outputSchema,
-					[],
-					new ConsoleLogger(),
-				);
-
-				const adaptor = new AWSLambdaFunction(new EnvironmentParser({}), fn);
-				const handler = adaptor.handler.bind(adaptor);
-
-				const mockContext = createMockContext();
-
-				const result = await handler(
-					{ message: 'Hello Lambda!' },
-					mockContext,
-					() => {},
-				);
-
-				expect(result).toEqual({
-					processed: 'Processed: Hello Lambda!',
-				});
-			});
-		});
-	});
-});

package/src/functions/__tests__/FunctionBuilder.state-isolation.spec.ts

@@ -1,207 +0,0 @@
-import type { AuditRecord, AuditStorage } from '@geekmidas/audit';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import { describe, expect, it } from 'vitest';
-import { FunctionBuilder } from '../FunctionBuilder';
-
-// In-memory audit storage for testing
-class InMemoryAuditStorage implements AuditStorage {
-	records: AuditRecord[] = [];
-
-	async write(records: AuditRecord[]): Promise<void> {
-		this.records.push(...records);
-	}
-
-	async query(): Promise<AuditRecord[]> {
-		return this.records;
-	}
-}
-
-const ServiceA = {
-	serviceName: 'a' as const,
-	async register() {
-		return { test: () => 'a' };
-	},
-} satisfies Service<'a', any>;
-
-const ServiceB = {
-	serviceName: 'b' as const,
-	async register() {
-		return { test: () => 'b' };
-	},
-} satisfies Service<'b', any>;
-
-describe('FunctionBuilder - State Isolation', () => {
-	describe('singleton instance state reset', () => {
-		it('should reset services after handle() is called', () => {
-			const f = new FunctionBuilder();
-
-			// First function with ServiceA and ServiceB
-			const fn1 = f.services([ServiceA, ServiceB]).handle(async () => ({}));
-
-			// Second function should not have any services from first
-			const fn2 = f.handle(async () => ({}));
-
-			expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-			expect(fn2.services).toEqual([]);
-		});
-
-		it('should reset logger after handle() is called', () => {
-			const f = new FunctionBuilder();
-			const customLogger = new ConsoleLogger({ app: 'custom' });
-
-			// First function with custom logger
-			const fn1 = f.logger(customLogger).handle(async () => ({}));
-
-			// Second function should have default logger (not the custom one)
-			const fn2 = f.handle(async () => ({}));
-
-			expect(fn1.logger).toBe(customLogger);
-			expect(fn2.logger).not.toBe(customLogger);
-			expect(fn2.logger).toBeInstanceOf(ConsoleLogger);
-		});
-
-		it('should reset events after handle() is called', () => {
-			const f = new FunctionBuilder();
-
-			// Create first function (events array should be empty initially)
-			const fn1 = f.handle(async () => ({}));
-
-			// Verify function was created and state was reset
-			expect(fn1).toBeDefined();
-			expect((f as any)._events).toEqual([]);
-			expect((f as any)._services).toEqual([]);
-		});
-
-		it('should reset input/output schemas after handle() is called', () => {
-			const f = new FunctionBuilder();
-			const inputSchema: any = { '~standard': { validate: () => ({}) } };
-			const outputSchema: any = { '~standard': { validate: () => ({}) } };
-
-			// First function with schemas
-			const fn1 = f
-				.input(inputSchema)
-				.output(outputSchema)
-				.handle(async () => ({}));
-
-			// Second function should not have schemas
-			const fn2 = f.handle(async () => ({}));
-
-			expect(fn1.input).toBe(inputSchema);
-			expect(fn1.outputSchema).toBe(outputSchema);
-			expect(fn2.input).toBeUndefined();
-			expect(fn2.outputSchema).toBeUndefined();
-		});
-
-		it('should reset timeout after handle() is called', () => {
-			const f = new FunctionBuilder();
-
-			// First function with custom timeout
-			const fn1 = f.timeout(5000).handle(async () => ({}));
-
-			// Second function should have default timeout (30000)
-			const fn2 = f.handle(async () => ({}));
-
-			expect(fn1.timeout).toBe(5000);
-			expect(fn2.timeout).toBe(30000); // Default timeout
-		});
-	});
-
-	describe('method chaining before handle()', () => {
-		it('should accumulate services when chaining', () => {
-			const f = new FunctionBuilder();
-
-			const fn = f
-				.services([ServiceA])
-				.services([ServiceB])
-				.handle(async () => ({}));
-
-			expect(fn.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-		});
-
-		it('should not share references between different builder chains', () => {
-			const f = new FunctionBuilder();
-
-			// Start two separate chains
-			const builder1 = f.services([ServiceA]);
-			const builder2 = f.services([ServiceB]);
-
-			// They should be the same instance (singleton)
-			expect(builder1).toBe(builder2);
-			expect(builder1).toBe(f);
-
-			// But after handle, state is reset
-			const fn1 = builder1.handle(async () => ({}));
-
-			// Now builder2 should have reset state
-			expect((builder2 as any)._services).toEqual([]);
-
-			// Add services again
-			const fn2 = builder2.services([ServiceB]).handle(async () => ({}));
-
-			expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-			expect(fn2.services.map((s) => s.serviceName)).toEqual(['b']);
-		});
-	});
-
-	describe('sequential function creation', () => {
-		it('should create independent functions sequentially', () => {
-			const f = new FunctionBuilder();
-
-			const fn1 = f
-				.services([ServiceA, ServiceB])
-				.handle(async () => ({ result: 1 }));
-			const fn2 = f.services([ServiceA]).handle(async () => ({ result: 2 }));
-			const fn3 = f.handle(async () => ({ result: 3 }));
-
-			expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-			expect(fn2.services.map((s) => s.serviceName)).toEqual(['a']);
-			expect(fn3.services).toEqual([]);
-		});
-	});
-
-	describe('publisher isolation', () => {
-		it('should reset publisher after handle() is called', () => {
-			const f = new FunctionBuilder();
-			const mockPublisher: any = {
-				serviceName: 'publisher',
-				async register() {
-					return { publish: () => {} };
-				},
-			};
-
-			const fn1 = f.publisher(mockPublisher).handle(async () => ({}));
-			const fn2 = f.handle(async () => ({}));
-
-			expect((fn1 as any).publisherService).toBe(mockPublisher);
-			expect((fn2 as any).publisherService).toBeUndefined();
-		});
-	});
-
-	describe('auditor isolation', () => {
-		const auditStorageService = {
-			serviceName: 'auditStorage' as const,
-			async register() {
-				return new InMemoryAuditStorage();
-			},
-		} satisfies Service<'auditStorage', InMemoryAuditStorage>;
-
-		it('should set auditor storage service', () => {
-			const f = new FunctionBuilder();
-
-			const fn1 = f.auditor(auditStorageService).handle(async () => ({}));
-
-			expect((fn1 as any).auditorStorageService).toBe(auditStorageService);
-		});
-
-		it('should reset auditor storage after handle() is called', () => {
-			const f = new FunctionBuilder();
-
-			const fn1 = f.auditor(auditStorageService).handle(async () => ({}));
-			const fn2 = f.handle(async () => ({}));
-
-			expect((fn1 as any).auditorStorageService).toBe(auditStorageService);
-			expect((fn2 as any).auditorStorageService).toBeUndefined();
-		});
-	});
-});