@geekmidas/constructs 9.0.2 → 10.0.0-alpha.1

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

@@ -1,480 +0,0 @@
-import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import { serviceContext } from '@geekmidas/services';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-
-import { Function } from '../Function';
-import { TestFunctionAdaptor } from '../TestFunctionAdaptor';
-
-// Mock services
-class TestService implements Service<'TestService', TestService> {
-	serviceName = 'TestService' as const;
-	static serviceName = 'TestService';
-
-	async register() {
-		return this;
-	}
-
-	getValue() {
-		return 'test-value';
-	}
-}
-
-// Mock event publisher
-type TestEvent = PublishableMessage<'test.event', { data: string }>;
-
-class TestPublisher implements EventPublisher<TestEvent> {
-	publishedEvents: TestEvent[] = [];
-
-	async publish(events: TestEvent[]): Promise<void> {
-		this.publishedEvents.push(...events);
-	}
-}
-
-class TestPublisherService
-	implements Service<'TestPublisherService', TestPublisher>
-{
-	serviceName = 'TestPublisherService' as const;
-	static serviceName = 'TestPublisherService';
-	publisher = new TestPublisher();
-
-	async register() {
-		return this.publisher;
-	}
-}
-
-describe.skip('TestFunctionAdaptor', () => {
-	let logger: ConsoleLogger;
-
-	beforeEach(() => {
-		logger = new ConsoleLogger();
-		vi.clearAllMocks();
-	});
-
-	describe('basic function execution', () => {
-		it('should execute a simple function without input/output schemas', async () => {
-			const fn = new Function(async () => {
-				return { message: 'Hello World' };
-			});
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			const result = await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(result).toEqual({ message: 'Hello World' });
-		});
-
-		it('should execute a function with input schema validation', async () => {
-			const inputSchema = z.object({ name: z.string() });
-			const handler = vi.fn(async ({ input }) => ({
-				message: `Hello ${input.name}`,
-			}));
-
-			const fn = new Function(
-				handler,
-				undefined,
-				undefined,
-				inputSchema,
-				undefined,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			const result = await adaptor.invoke({
-				input: { name: 'TypeScript' },
-				services: {},
-			});
-
-			expect(result).toEqual({ message: 'Hello TypeScript' });
-			expect(handler).toHaveBeenCalledWith(
-				expect.objectContaining({
-					input: { name: 'TypeScript' },
-				}),
-			);
-		});
-
-		it('should fail with invalid input', async () => {
-			const inputSchema = z.object({ age: z.number() });
-			const fn = new Function(
-				async () => ({ success: true }),
-				undefined,
-				undefined,
-				inputSchema,
-				undefined,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await expect(
-				adaptor.invoke({ input: { age: 'not a number' as any }, services: {} }),
-			).rejects.toThrow();
-		});
-
-		it('should validate output schema', async () => {
-			const outputSchema = z.object({
-				id: z.string(),
-				timestamp: z.number(),
-			});
-
-			const fn = new Function(
-				async () => ({
-					id: '123',
-					timestamp: Date.now(),
-				}),
-				undefined,
-				undefined,
-				undefined,
-				outputSchema,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			const result = await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(result).toMatchObject({
-				id: '123',
-				timestamp: expect.any(Number),
-			});
-		});
-
-		it('should fail with invalid output', async () => {
-			const outputSchema = z.object({
-				id: z.string(),
-			});
-
-			const fn = new Function(
-				async () => ({
-					id: '123', // Fixed: should be string
-				}),
-				undefined,
-				undefined,
-				undefined,
-				outputSchema,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			// This should not throw since output is valid
-			const result = await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(result).toEqual({ id: '123' });
-		});
-	});
-
-	describe('services', () => {
-		it('should inject services into function context', async () => {
-			const service = new TestService();
-			const handler = vi.fn(async ({ services }) => ({
-				value: services.TestService.getValue(),
-			}));
-
-			const fn = new Function(
-				handler,
-				undefined,
-				undefined,
-				undefined,
-				undefined,
-				[service],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			const result = await adaptor.invoke({
-				input: {},
-				services: {} as any,
-			});
-
-			expect(result).toEqual({ value: 'test-value' });
-			expect(handler).toHaveBeenCalledWith(
-				expect.objectContaining({
-					services: expect.objectContaining({
-						TestService: expect.any(TestService),
-					}),
-				}),
-			);
-		});
-
-		// Service overriding in context is not currently supported
-	});
-
-	describe('logging', () => {
-		it('should create child logger with test context', async () => {
-			const mockLogger = {
-				child: vi.fn().mockReturnThis(),
-				info: vi.fn(),
-				error: vi.fn(),
-				warn: vi.fn(),
-				debug: vi.fn(),
-			};
-
-			const fn = new Function(
-				async ({ logger }) => {
-					logger.info('Function executed');
-					return { success: true };
-				},
-				undefined,
-				undefined,
-				undefined,
-				undefined,
-				[],
-				mockLogger as any,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(mockLogger.child).toHaveBeenCalledWith({
-				test: true,
-			});
-			expect(mockLogger.info).toHaveBeenCalledWith('Function executed');
-		});
-	});
-
-	describe('events', () => {
-		it('should publish events after successful execution', async () => {
-			const publisherService = new TestPublisherService();
-
-			const fn = new Function(
-				async () => ({ id: '123' }),
-				undefined,
-				undefined,
-				undefined,
-				z.object({ id: z.string() }),
-				[],
-				logger,
-				publisherService,
-				[
-					{
-						type: 'test.event',
-						payload: (response) => ({ data: response.id }),
-					},
-				],
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-				publisher: publisherService,
-			});
-
-			expect(publisherService.publisher.publishedEvents).toHaveLength(1);
-			expect(publisherService.publisher.publishedEvents[0]).toEqual({
-				type: 'test.event',
-				payload: { data: '123' },
-			});
-		});
-
-		it('should conditionally publish events based on when clause', async () => {
-			const publisherService = new TestPublisherService();
-
-			const fn = new Function(
-				async () => ({ success: false }),
-				undefined,
-				undefined,
-				undefined,
-				z.object({ success: z.boolean() }),
-				[],
-				logger,
-				publisherService,
-				[
-					{
-						type: 'test.event',
-						payload: () => ({ data: 'test' }),
-						when: (response) => response.success === true,
-					},
-				],
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-				publisher: publisherService,
-			});
-
-			expect(publisherService.publisher.publishedEvents).toHaveLength(0);
-		});
-
-		it('should work without publisher service in context', async () => {
-			const publisherService = new TestPublisherService();
-
-			const fn = new Function(
-				async () => ({ id: '123' }),
-				undefined,
-				undefined,
-				undefined,
-				z.object({ id: z.string() }),
-				[],
-				logger,
-				publisherService,
-				[
-					{
-						type: 'test.event',
-						payload: (response) => ({ data: response.id }),
-					},
-				],
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			// Should not throw when publisher is not provided in context
-			const result = await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-			expect(result).toEqual({ id: '123' });
-		});
-	});
-
-	describe('default service discovery', () => {
-		it('should create default service discovery', () => {
-			const fn = new Function(async () => ({ success: true }));
-			const serviceDiscovery =
-				TestFunctionAdaptor.getDefaultServiceDiscovery(fn);
-
-			expect(serviceDiscovery).toBeDefined();
-		});
-
-		it('should use custom service discovery when provided', async () => {
-			const fn = new Function(async () => ({ success: true }));
-			const mockServiceDiscovery = {
-				register: vi.fn().mockResolvedValue({}),
-				getInstance: vi.fn(),
-			} as any;
-
-			const adaptor = new TestFunctionAdaptor(fn, mockServiceDiscovery);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(mockServiceDiscovery.register).toHaveBeenCalledWith([]);
-		});
-	});
-
-	describe('error handling', () => {
-		it('should propagate errors from function execution', async () => {
-			const fn = new Function(async () => {
-				throw new Error('Function failed');
-			});
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await expect(
-				adaptor.invoke({
-					input: {},
-					services: {},
-				}),
-			).rejects.toThrow('Function failed');
-		});
-	});
-
-	describe('request context', () => {
-		it('should make serviceContext.getLogger() available inside handler', async () => {
-			let contextLogger: any;
-
-			const fn = new Function(
-				async () => {
-					contextLogger = serviceContext.getLogger();
-					return { success: true };
-				},
-				undefined,
-				undefined,
-				undefined,
-				undefined,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(contextLogger).toBeDefined();
-		});
-
-		it('should make serviceContext.hasContext() return true inside handler', async () => {
-			let hasContext = false;
-
-			const fn = new Function(
-				async () => {
-					hasContext = serviceContext.hasContext();
-					return { success: true };
-				},
-				undefined,
-				undefined,
-				undefined,
-				undefined,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(hasContext).toBe(true);
-		});
-
-		it('should provide a request ID starting with test-', async () => {
-			let requestId: string | undefined;
-
-			const fn = new Function(
-				async () => {
-					requestId = serviceContext.getRequestId();
-					return { success: true };
-				},
-				undefined,
-				undefined,
-				undefined,
-				undefined,
-				[],
-				logger,
-			);
-
-			const adaptor = new TestFunctionAdaptor(fn);
-
-			await adaptor.invoke({
-				input: {},
-				services: {},
-			});
-
-			expect(requestId).toBeDefined();
-			expect(requestId).toMatch(/^test-/);
-		});
-	});
-});

package/src/functions/index.ts

@@ -1,12 +0,0 @@
-export { BaseFunctionBuilder } from './BaseFunctionBuilder';
-export {
-	Function,
-	type FunctionContext,
-	type FunctionHandler,
-} from './Function';
-
-import { FunctionBuilder } from './FunctionBuilder';
-
-export { FunctionBuilder } from './FunctionBuilder';
-
-export const f = new FunctionBuilder();

package/src/index.ts

@@ -1,23 +0,0 @@
-// Core construct types
-
-// Re-export from services for convenience
-export type { Service, ServiceRecord } from '@geekmidas/services';
-export {
-	Construct,
-	ConstructType,
-	snifferContext,
-	sniffService,
-} from './Construct';
-// Telemetry interface
-export type {
-	Telemetry,
-	TelemetryContext,
-	TelemetryRequest,
-	TelemetryResponse,
-} from './telemetry';
-// Types
-export type {
-	HttpMethod,
-	LowerHttpMethod,
-	RemoveUndefined,
-} from './types';

package/src/publisher.ts

@@ -1,93 +0,0 @@
-import type { AuditStorage } from '@geekmidas/audit';
-import type { EventPublisher, MappedEvent } from '@geekmidas/events';
-import type { Logger } from '@geekmidas/logger';
-import type { InferStandardSchema } from '@geekmidas/schema';
-import type { Service, ServiceDiscovery } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Construct } from './Construct';
-
-export async function publishEvents<
-	T extends EventPublisher<any> | undefined,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TServiceName extends string = string,
-	TPublisherService extends Service<TServiceName, T> | undefined = undefined,
->(
-	logger: Logger,
-	serviceDiscovery: ServiceDiscovery<any>,
-	ev: MappedEvent<T, OutSchema>[] = [],
-	response: InferStandardSchema<OutSchema>,
-	publisherService: TPublisherService,
-) {
-	try {
-		if (!ev?.length) {
-			logger.debug('No events to publish');
-			return;
-		}
-		if (!publisherService) {
-			logger.warn('No publisher service available');
-			return;
-		}
-
-		const services = await serviceDiscovery.register([publisherService]);
-
-		const publisher = services[
-			publisherService.serviceName
-		] as EventPublisher<any>;
-
-		const events: MappedEvent<T, OutSchema>[] = [];
-
-		for (const { when, payload, type, ...e } of ev) {
-			logger.debug({ event: type }, 'Processing event');
-			const resolvedPayload = await payload(response);
-			const event = {
-				...e,
-				type,
-				payload: resolvedPayload,
-			};
-
-			if (!when || when(response as any)) {
-				events.push(event);
-			}
-		}
-
-		if (events.length) {
-			logger.debug({ eventCount: ev.length }, 'Publishing events');
-
-			await publisher.publish(events).catch((err) => {
-				logger.error(err, 'Failed to publish events');
-			});
-		}
-	} catch (error) {
-		logger.error(error as any, 'Something went wrong publishing events');
-	}
-}
-
-export async function publishConstructEvents<
-	T extends EventPublisher<any> | undefined,
-	OutSchema extends StandardSchemaV1 | undefined = undefined,
-	TServiceName extends string = string,
-	TServices extends Service[] = [],
-	TAuditStorageServiceName extends string = string,
-	TAuditStorage extends AuditStorage | undefined = undefined,
->(
-	construct: Construct<
-		Logger,
-		TServiceName,
-		T,
-		OutSchema,
-		TServices,
-		TAuditStorageServiceName,
-		TAuditStorage
-	>,
-	response: InferStandardSchema<OutSchema>,
-	serviceDiscovery: ServiceDiscovery<any>,
-	logger: Logger = construct.logger,
-) {
-	return publishEvents(
-		logger,
-		serviceDiscovery,
-		construct.events,
-		response,
-		construct.publisherService,
-	);
-}