@geekmidas/constructs 0.0.1

package/src/functions/FunctionExecutionWrapper.ts

@@ -0,0 +1,86 @@
+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,
+> {
+  constructor(
+    protected envParser: EnvironmentParser<{}>,
+    protected readonly fn: Function<
+      TInput,
+      TServices,
+      TLogger,
+      TOutSchema,
+      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ) {}
+
+  protected _logger?: TLogger;
+
+  get logger(): TLogger {
+    return this._logger || this.fn.logger;
+  }
+
+  get serviceDiscovery(): ServiceDiscovery<ServiceRecord<TServices>, Logger> {
+    const serviceDiscovery = ServiceDiscovery.getInstance<
+      ServiceRecord<TServices>,
+      TLogger
+    >(this.logger, this.envParser);
+
+    return serviceDiscovery;
+  }
+
+  getServices(): Promise<ServiceRecord<TServices>> {
+    return this.serviceDiscovery.register(this.fn.services);
+  }
+
+  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

@@ -0,0 +1,125 @@
+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 {
+  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 StandardSchemaV1 | undefined = undefined,
+  TOutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> {
+  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,
+  >(
+    fn: Function<
+      TInput,
+      TServices,
+      TLogger,
+      TOutSchema,
+      any,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ) {
+    return ServiceDiscovery.getInstance(fn.logger, new EnvironmentParser({}));
+  }
+
+  constructor(
+    private readonly fn: Function<
+      TInput,
+      TServices,
+      TLogger,
+      TOutSchema,
+      any,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+    private serviceDiscovery: ServiceDiscovery<
+      any,
+      any
+    > = TestFunctionAdaptor.getDefaultServiceDiscovery(fn),
+  ) {}
+
+  async invoke(
+    ctx: TestFunctionRequest<
+      TInput,
+      TServices,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ): 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);
+    }
+
+    // Execute the function
+    const response = await this.fn['fn']({
+      input: parsedInput,
+      services,
+      logger,
+    });
+
+    // Parse output if schema is provided
+    const output = await this.fn.parseOutput(response);
+
+    // Register publisher service if provided in context
+
+    await publishEvents(
+      logger,
+      this.serviceDiscovery,
+      this.fn.events,
+      output,
+      this.fn.publisherService,
+    );
+
+    return output;
+  }
+}
+
+export type TestFunctionRequest<
+  TInput extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> = {
+  input: InferComposableStandardSchema<TInput>;
+  services: ServiceRecord<TServices>;
+  publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
+} & InferComposableStandardSchema<{ input: TInput }>;

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

@@ -0,0 +1,376 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type { Service } from '@geekmidas/services';
+import type { Context } from 'aws-lambda';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod/v4';
+import { AWSLambdaFunction } from '../AWSLambdaFunction';
+import { Function } from '../Function';
+
+// 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;
+  }
+}
+
+// Mock Lambda context
+const createMockContext = (): Context => ({
+  functionName: 'test-function',
+  functionVersion: '1',
+  invokedFunctionArn: 'arn:aws:lambda:region:account:function:test-function',
+  memoryLimitInMB: '128',
+  awsRequestId: 'test-request-id',
+  logGroupName: '/aws/lambda/test-function',
+  logStreamName: '2023/01/01/[$LATEST]test-stream',
+  getRemainingTimeInMillis: () => 30000,
+  done: vi.fn(),
+  fail: vi.fn(),
+  succeed: vi.fn(),
+  callbackWaitsForEmptyEventLoop: true,
+});
+
+describe('AWSLambdaFunction', () => {
+  let envParser: EnvironmentParser<{}>;
+  let logger: ConsoleLogger;
+
+  beforeEach(() => {
+    envParser = new EnvironmentParser({});
+    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 ({ input }) => {
+        return { message: `Hello ` };
+      });
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      const result = await handler(
+        { name: 'World' },
+        createMockContext(),
+        vi.fn(),
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should execute a function with input schema validation', async () => {
+      const inputSchema = { name: z.string() };
+      const outputSchema = z.object({ message: z.string() });
+      const handler = vi.fn(async ({ input }) => ({
+        message: `Hello ${input.name}`,
+      }));
+
+      const fn = new Function(
+        handler,
+        undefined,
+        undefined,
+        inputSchema,
+        outputSchema,
+        [],
+        logger,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const lambdaHandler = adaptor.handler;
+
+      const result = await lambdaHandler(
+        { name: 'TypeScript' },
+        createMockContext(),
+        vi.fn(),
+      );
+
+      expect(result).toEqual({ message: 'Hello TypeScript' });
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: { name: 'TypeScript' },
+        }),
+      );
+    });
+
+    it('should fail with invalid input', async () => {
+      const inputSchema = { age: z.number() };
+      const fn = new Function(
+        async () => ({ success: true }),
+        undefined,
+        undefined,
+        inputSchema,
+        undefined,
+        [],
+        logger,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await expect(
+        handler({ age: 'not a number' }, createMockContext(), vi.fn()),
+      ).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 AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      const result = await handler({}, createMockContext(), vi.fn());
+
+      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(
+        // @ts-ignore
+        async () => ({
+          id: 123, // Invalid type, should be string
+        }),
+        undefined,
+        undefined,
+        undefined,
+        outputSchema,
+        [],
+        logger,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await expect(handler({}, createMockContext(), vi.fn())).rejects.toThrow();
+    });
+  });
+
+  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 schema = z.object({ value: z.string() });
+      const fn = new Function(
+        handler,
+        undefined,
+        undefined,
+        undefined,
+        schema,
+        [service],
+        logger,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const lambdaHandler = adaptor.handler;
+
+      const result = await lambdaHandler({}, createMockContext(), vi.fn());
+
+      expect(result).toEqual({ value: 'test-value' });
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          services: expect.objectContaining({
+            TestService: expect.any(TestService),
+          }),
+        }),
+      );
+    });
+  });
+
+  describe('logging', () => {
+    it('should create child logger with Lambda 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 AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      const context = createMockContext();
+      await handler({}, context, vi.fn());
+
+      expect(mockLogger.child).toHaveBeenCalledWith({
+        fn: {
+          name: 'test-function',
+          version: '1',
+          memory: '128',
+        },
+        req: {
+          id: 'test-request-id',
+        },
+      });
+      expect(mockLogger.info).toHaveBeenCalledWith('Function executed');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should wrap and log errors', async () => {
+      const mockLogger = {
+        child: vi.fn().mockReturnThis(),
+        error: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+      };
+
+      const fn = new Function(
+        async () => {
+          throw new Error('Function failed');
+        },
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        [],
+        mockLogger as any,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await expect(handler({}, createMockContext(), vi.fn())).rejects.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.any(Error),
+        'Error processing function',
+      );
+    });
+  });
+
+  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 AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await handler({}, createMockContext(), vi.fn());
+
+      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 AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await handler({}, createMockContext(), vi.fn());
+
+      expect(publisherService.publisher.publishedEvents).toHaveLength(0);
+    });
+  });
+
+  // Skipping timeout tests for now as middleware order needs to be adjusted
+});