@geekmidas/constructs 0.0.12 → 0.0.13

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

@@ -0,0 +1,393 @@
+import type {
+  AuditRecord,
+  AuditStorage,
+  AuditableAction,
+} from '@geekmidas/audit';
+import { EnvironmentParser } from '@geekmidas/envkit';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod/v4';
+
+import { AWSLambdaFunction } from '../AWSLambdaFunction';
+import { FunctionBuilder } from '../FunctionBuilder';
+import { TestFunctionAdaptor } from '../TestFunctionAdaptor';
+
+// Define audit action types for type-safety
+type UserAuditActions =
+  | AuditableAction<'user.processed', { userId: string; status: string }>
+  | AuditableAction<'user.failed', { userId: string; reason: string }>;
+
+// Mock audit storage
+class MockAuditStorage implements AuditStorage {
+  storedRecords: AuditRecord[] = [];
+
+  async write(records: AuditRecord[]): Promise<void> {
+    this.storedRecords.push(...records);
+  }
+
+  getDatabase() {
+    return undefined;
+  }
+}
+
+// Audit storage service - use unique names to avoid ServiceDiscovery caching
+let serviceCounter = 0;
+const createAuditStorageService = <T extends string>(
+  storage: MockAuditStorage,
+  name?: T,
+) => ({
+  serviceName: (name ?? `auditStorage-${++serviceCounter}`) as T extends string
+    ? T
+    : `auditStorage-${number}`,
+  async register() {
+    return storage;
+  },
+});
+
+describe('Function Audits', () => {
+  let logger: ConsoleLogger;
+  let envParser: EnvironmentParser<{}>;
+
+  beforeEach(() => {
+    logger = new ConsoleLogger();
+    envParser = new EnvironmentParser({});
+    vi.clearAllMocks();
+  });
+
+  describe('FunctionBuilder with auditor', () => {
+    it('should configure auditor storage service', () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .output(z.object({ result: z.string() }))
+        .handle(async () => {
+          return { result: 'success' };
+        });
+
+      expect(fn.auditorStorageService).toBe(auditStorageService);
+    });
+
+    it('should provide type-safe auditor via actions()', () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .output(z.object({ result: z.string() }))
+        .handle(async ({ auditor }) => {
+          // auditor should be typed with UserAuditActions
+          if (auditor) {
+            auditor.audit('user.processed', {
+              userId: '123',
+              status: 'active',
+            });
+          }
+          return { result: 'success' };
+        });
+
+      expect(fn.auditorStorageService).toBe(auditStorageService);
+    });
+  });
+
+  describe('TestFunctionAdaptor with auditor', () => {
+    it('should inject auditor and flush audits', async () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .input({ userId: z.string() })
+        .output(z.object({ processed: z.boolean() }))
+        .handle(async ({ input, auditor }) => {
+          if (auditor) {
+            auditor.audit('user.processed', {
+              userId: input.userId,
+              status: 'completed',
+            });
+          }
+          return { processed: true };
+        });
+
+      const adaptor = new TestFunctionAdaptor(fn);
+      const result = await adaptor.invoke({
+        input: { userId: 'user-123' },
+        services: {},
+      });
+
+      expect(result).toEqual({ processed: true });
+      expect(auditStorage.storedRecords).toHaveLength(1);
+      expect(auditStorage.storedRecords[0]).toMatchObject({
+        type: 'user.processed',
+        payload: { userId: 'user-123', status: 'completed' },
+      });
+    });
+
+    it('should work without auditor when not configured', async () => {
+      const fn = new FunctionBuilder()
+        .input({ value: z.number() })
+        .output(z.object({ doubled: z.number() }))
+        .handle(async (ctx) => {
+          // auditor should be undefined when not configured
+          // Use type assertion since it's not in the type when not configured
+          expect((ctx as any).auditor).toBeUndefined();
+          return { doubled: ctx.input.value * 2 };
+        });
+
+      const adaptor = new TestFunctionAdaptor(fn);
+      const result = await adaptor.invoke({
+        input: { value: 5 },
+        services: {},
+      });
+
+      expect(result).toEqual({ doubled: 10 });
+    });
+
+    it('should allow injecting custom auditor', async () => {
+      const customAuditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(customAuditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .input({ trigger: z.string() })
+        .output(z.object({ success: z.boolean() }))
+        .handle(async ({ auditor }) => {
+          if (auditor) {
+            auditor.audit('user.processed', {
+              userId: 'custom',
+              status: 'custom-audit',
+            });
+          }
+          return { success: true };
+        });
+
+      // Create a custom auditor with different storage
+      const testStorage = new MockAuditStorage();
+      const { DefaultAuditor } = await import('@geekmidas/audit');
+      const customAuditor = new DefaultAuditor<UserAuditActions>({
+        actor: { id: 'test', type: 'test' },
+        storage: testStorage,
+        metadata: { test: true },
+      });
+
+      const adaptor = new TestFunctionAdaptor(fn);
+      const result = await adaptor.invoke({
+        input: { trigger: 'test' },
+        services: {},
+        auditor: customAuditor,
+      });
+
+      expect(result).toEqual({ success: true });
+      // Custom auditor's storage should have the records
+      expect(testStorage.storedRecords).toHaveLength(1);
+      // Default storage should be empty
+      expect(customAuditStorage.storedRecords).toHaveLength(0);
+    });
+
+    it('should record multiple audits in single invocation', async () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .input({ userIds: z.array(z.string()) })
+        .output(z.object({ processed: z.number() }))
+        .handle(async ({ input, auditor }) => {
+          for (const userId of input.userIds) {
+            if (auditor) {
+              auditor.audit('user.processed', {
+                userId,
+                status: 'batch-processed',
+              });
+            }
+          }
+          return { processed: input.userIds.length };
+        });
+
+      const adaptor = new TestFunctionAdaptor(fn);
+      const result = await adaptor.invoke({
+        input: { userIds: ['user-1', 'user-2', 'user-3'] },
+        services: {},
+      });
+
+      expect(result).toEqual({ processed: 3 });
+      expect(auditStorage.storedRecords).toHaveLength(3);
+      expect(auditStorage.storedRecords.map((r) => r.payload)).toEqual([
+        { userId: 'user-1', status: 'batch-processed' },
+        { userId: 'user-2', status: 'batch-processed' },
+        { userId: 'user-3', status: 'batch-processed' },
+      ]);
+    });
+  });
+
+  describe('AWSLambdaFunction with auditor', () => {
+    const createMockLambdaContext = () => ({
+      functionName: 'test-function',
+      functionVersion: '1',
+      invokedFunctionArn: 'arn:aws:lambda:region:account:function:test',
+      memoryLimitInMB: '128',
+      awsRequestId: 'test-request-id',
+      logGroupName: '/aws/lambda/test',
+      logStreamName: '2023/01/01/[$LATEST]test',
+      getRemainingTimeInMillis: () => 30000,
+      done: vi.fn(),
+      fail: vi.fn(),
+      succeed: vi.fn(),
+      callbackWaitsForEmptyEventLoop: true,
+    });
+
+    it('should inject auditor in Lambda handler', async () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .logger(logger)
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .input({ action: z.string() })
+        .output(z.object({ completed: z.boolean() }))
+        .handle(async ({ input, auditor }) => {
+          if (auditor) {
+            auditor.audit('user.processed', {
+              userId: 'lambda-user',
+              status: input.action,
+            });
+          }
+          return { completed: true };
+        });
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      const result = await handler(
+        { action: 'lambda-action' },
+        createMockLambdaContext(),
+        vi.fn(),
+      );
+
+      expect(result).toEqual({ completed: true });
+      expect(auditStorage.storedRecords).toHaveLength(1);
+      expect(auditStorage.storedRecords[0]).toMatchObject({
+        type: 'user.processed',
+        payload: { userId: 'lambda-user', status: 'lambda-action' },
+      });
+    });
+
+    it('should work without auditor when not configured', async () => {
+      const fn = new FunctionBuilder()
+        .logger(logger)
+        .input({ value: z.number() })
+        .output(z.object({ result: z.number() }))
+        .handle(async (ctx) => {
+          // Use type assertion since auditor is not in type when not configured
+          expect((ctx as any).auditor).toBeUndefined();
+          return { result: ctx.input.value + 1 };
+        });
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      const result = await handler(
+        { value: 10 },
+        createMockLambdaContext(),
+        vi.fn(),
+      );
+
+      expect(result).toEqual({ result: 11 });
+    });
+
+    it('should flush audits after successful execution', async () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .logger(logger)
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .output(z.object({ status: z.string() }))
+        .handle(async ({ auditor }) => {
+          if (auditor) {
+            auditor.audit('user.processed', {
+              userId: 'flush-test',
+              status: 'pending',
+            });
+          }
+          return { status: 'ok' };
+        });
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await handler({}, createMockLambdaContext(), vi.fn());
+
+      // Records should be flushed
+      expect(auditStorage.storedRecords).toHaveLength(1);
+    });
+
+    it('should not flush audits if none were recorded', async () => {
+      const auditStorage = new MockAuditStorage();
+      const writeSpy = vi.spyOn(auditStorage, 'write');
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .logger(logger)
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .output(z.object({ status: z.string() }))
+        .handle(async () => {
+          // Don't record any audits
+          return { status: 'no-audits' };
+        });
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const handler = adaptor.handler;
+
+      await handler({}, createMockLambdaContext(), vi.fn());
+
+      // write should not be called
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Auditor with entity tracking', () => {
+    it('should record audits with entityId and table', async () => {
+      const auditStorage = new MockAuditStorage();
+      const auditStorageService = createAuditStorageService(auditStorage);
+
+      const fn = new FunctionBuilder()
+        .auditor(auditStorageService)
+        .actions<UserAuditActions>()
+        .input({ userId: z.string() })
+        .output(z.object({ success: z.boolean() }))
+        .handle(async ({ input, auditor }) => {
+          if (auditor) {
+            auditor.audit(
+              'user.processed',
+              { userId: input.userId, status: 'active' },
+              { entityId: input.userId, table: 'users' },
+            );
+          }
+          return { success: true };
+        });
+
+      const adaptor = new TestFunctionAdaptor(fn);
+      await adaptor.invoke({
+        input: { userId: 'entity-123' },
+        services: {},
+      });
+
+      expect(auditStorage.storedRecords).toHaveLength(1);
+      expect(auditStorage.storedRecords[0]).toMatchObject({
+        type: 'user.processed',
+        entityId: 'entity-123',
+        table: 'users',
+      });
+    });
+  });
+});

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

@@ -305,6 +305,82 @@ describe('Function', () => {
         // _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);
+      });
     });
   });
 

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

@@ -43,7 +43,7 @@ describe('FunctionBuilder - State Isolation', () => {
       const fn2 = f.handle(async () => ({}));
 
       expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
-      expect(fn2.services.map((s) => s.serviceName)).toEqual([]);
+      expect(fn2.services).toEqual([]);
     });
 
     it('should reset logger after handle() is called', () => {
@@ -67,7 +67,8 @@ describe('FunctionBuilder - State Isolation', () => {
       // Create first function (events array should be empty initially)
       const fn1 = f.handle(async () => ({}));
 
-      // Verify state was reset
+      // Verify function was created and state was reset
+      expect(fn1).toBeDefined();
       expect((f as any)._events).toEqual([]);
       expect((f as any)._services).toEqual([]);
     });
@@ -78,7 +79,10 @@ describe('FunctionBuilder - State Isolation', () => {
       const outputSchema: any = { '~standard': { validate: () => ({}) } };
 
       // First function with schemas
-      const fn1 = f.input(inputSchema).output(outputSchema).handle(async () => ({}));
+      const fn1 = f
+        .input(inputSchema)
+        .output(outputSchema)
+        .handle(async () => ({}));
 
       // Second function should not have schemas
       const fn2 = f.handle(async () => ({}));
@@ -144,13 +148,15 @@ describe('FunctionBuilder - State Isolation', () => {
     it('should create independent functions sequentially', () => {
       const f = new FunctionBuilder();
 
-      const fn1 = f.services([ServiceA, ServiceB]).handle(async () => ({ result: 1 }));
+      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.map((s) => s.serviceName)).toEqual([]);
+      expect(fn3.services).toEqual([]);
     });
   });
 

package/src/publisher.ts

@@ -1,3 +1,4 @@
+import type { AuditStorage } from '@geekmidas/audit';
 import type { Logger } from '@geekmidas/logger';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 
@@ -67,8 +68,18 @@ export async function publishConstructEvents<
   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>,
+  construct: Construct<
+    Logger,
+    TServiceName,
+    T,
+    OutSchema,
+    TServices,
+    TAuditStorageServiceName,
+    TAuditStorage
+  >,
   response: InferStandardSchema<OutSchema>,
   serviceDiscovery: ServiceDiscovery<any, any>,
   logger: Logger = construct.logger,

package/dist/AWSLambdaFunction-DMxScuaw.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AWSLambdaFunction-DMxScuaw.cjs","names":["FunctionExecutionWrapper","envParser: EnvironmentParser<{}>","fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >","event: FunctionEvent<TEvent, TInput, TServices, TLogger>"],"sources":["../src/functions/AWSLambdaFunction.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport middy, { type MiddlewareObj } from '@middy/core';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Context, Handler } from 'aws-lambda';\nimport type { Function, FunctionHandler } from './Function';\nimport { FunctionBuilder } from './FunctionBuilder';\n\nimport { wrapError } from '@geekmidas/errors';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n  ComposableStandardSchema,\n  InferComposableStandardSchema,\n  InferStandardSchema,\n} from '@geekmidas/schema';\nimport type { Service, ServiceRecord } from '@geekmidas/services';\nimport { FunctionExecutionWrapper } from './FunctionExecutionWrapper';\n\nexport type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<\n  TEvent,\n  TResult\n>;\n\ntype FunctionEvent<\n  TEvent,\n  TInput extends ComposableStandardSchema | undefined,\n  TServices extends Service[],\n  TLogger extends Logger,\n> = TEvent & {\n  parsedInput: InferComposableStandardSchema<TInput>;\n  services: ServiceRecord<TServices>;\n  logger: TLogger;\n};\n\ntype Middleware<\n  TEvent,\n  TInput extends ComposableStandardSchema | undefined,\n  TServices extends Service[],\n  TLogger extends Logger,\n  TOutSchema extends StandardSchemaV1 | undefined,\n> = MiddlewareObj<\n  FunctionEvent<TEvent, TInput, TServices, TLogger>,\n  InferComposableStandardSchema<TOutSchema>,\n  Error,\n  Context\n>;\n\nexport class AWSLambdaFunction<\n  TInput extends ComposableStandardSchema | undefined = undefined,\n  TOutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> extends FunctionExecutionWrapper<\n  TInput,\n  TOutSchema,\n  TServices,\n  TLogger,\n  TEventPublisher,\n  TEventPublisherServiceName\n> {\n  constructor(\n    envParser: EnvironmentParser<{}>,\n    readonly fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ) {\n    super(envParser, fn);\n  }\n\n  private error<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      onError: (req) => {\n        const logger = req.event?.logger || this.fn.logger;\n        logger.error(req.error || {}, 'Error processing function');\n\n        // Re-throw the wrapped error to let Lambda handle it\n        throw wrapError(req.error);\n      },\n    };\n  }\n\n  private baseInput<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: (req) => {},\n    };\n  }\n\n  private input<\n    TEvent extends { input: InferComposableStandardSchema<TInput> },\n  >(): Middleware<TEvent, TInput, TServices, TLogger, TOutSchema> {\n    return {\n      before: async (req) => {\n        try {\n          // Parse input if schema is provided\n          if (this.fn.input) {\n            const parsedInput =\n              await FunctionBuilder.parseComposableStandardSchema(\n                req.event,\n                this.fn.input,\n              );\n\n            req.event.parsedInput =\n              parsedInput as InferComposableStandardSchema<TInput>;\n          } else {\n            // If no schema, pass the event as-is\n            req.event.parsedInput = req.event as any;\n          }\n        } catch (error) {\n          this.logger.error(\n            { error, event: req.event },\n            'Failed to parse input',\n          );\n          throw error;\n        }\n      },\n    };\n  }\n\n  private loggerMiddleware<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: (req) => {\n        this._logger = this.fn.logger.child({\n          fn: {\n            name: req.context.functionName,\n            version: req.context.functionVersion,\n            memory: req.context.memoryLimitInMB,\n          },\n          req: {\n            id: req.context.awsRequestId,\n          },\n        }) as TLogger;\n\n        req.event.logger = this._logger;\n      },\n    };\n  }\n\n  private services<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: async (req) => {\n        req.event.services = await this.getServices();\n      },\n    };\n  }\n\n  private events<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      after: async (req) => {\n        const response = (req.response ||\n          undefined) as InferStandardSchema<TOutSchema>;\n        await this.publishEvents(response);\n      },\n    };\n  }\n\n  private async _handler<TEvent>(\n    event: FunctionEvent<TEvent, TInput, TServices, TLogger>,\n  ) {\n    // Execute the function with the parsed context\n    const result = await this.fn['fn']({\n      input: event.parsedInput,\n      services: event.services,\n      logger: event.logger,\n    });\n\n    // Parse output if schema is provided\n    const output = await this.fn.parseOutput(result);\n\n    return output;\n  }\n\n  get handler(): AWSLambdaHandler {\n    const handler = this._handler.bind(this);\n\n    // Apply middleware in order\n    return middy(handler)\n      .use(this.loggerMiddleware())\n      .use(this.baseInput())\n      .use(this.error())\n      .use(this.services())\n      .use(this.input())\n      .use(this.events()) as unknown as AWSLambdaHandler;\n  }\n}\n"],"mappings":";;;;;;;AA+CA,IAAa,oBAAb,cAOUA,0DAOR;CACA,YACEC,WACSC,IAST;AACA,QAAM,WAAW,GAAG;EAVX;CAWV;CAED,AAAQ,QAMN;AACA,SAAO,EACL,SAAS,CAAC,QAAQ;GAChB,MAAM,SAAS,IAAI,OAAO,UAAU,KAAK,GAAG;AAC5C,UAAO,MAAM,IAAI,SAAS,CAAE,GAAE,4BAA4B;AAG1D,SAAM,kCAAU,IAAI,MAAM;EAC3B,EACF;CACF;CAED,AAAQ,YAMN;AACA,SAAO,EACL,QAAQ,CAAC,QAAQ,CAAE,EACpB;CACF;CAED,AAAQ,QAEwD;AAC9D,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI;AAEF,QAAI,KAAK,GAAG,OAAO;KACjB,MAAM,cACJ,MAAM,wCAAgB,8BACpB,IAAI,OACJ,KAAK,GAAG,MACT;AAEH,SAAI,MAAM,cACR;IACH,MAEC,KAAI,MAAM,cAAc,IAAI;GAE/B,SAAQ,OAAO;AACd,SAAK,OAAO,MACV;KAAE;KAAO,OAAO,IAAI;IAAO,GAC3B,wBACD;AACD,UAAM;GACP;EACF,EACF;CACF;CAED,AAAQ,mBAMN;AACA,SAAO,EACL,QAAQ,CAAC,QAAQ;AACf,QAAK,UAAU,KAAK,GAAG,OAAO,MAAM;IAClC,IAAI;KACF,MAAM,IAAI,QAAQ;KAClB,SAAS,IAAI,QAAQ;KACrB,QAAQ,IAAI,QAAQ;IACrB;IACD,KAAK,EACH,IAAI,IAAI,QAAQ,aACjB;GACF,EAAC;AAEF,OAAI,MAAM,SAAS,KAAK;EACzB,EACF;CACF;CAED,AAAQ,WAMN;AACA,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI,MAAM,WAAW,MAAM,KAAK,aAAa;EAC9C,EACF;CACF;CAED,AAAQ,SAMN;AACA,SAAO,EACL,OAAO,OAAO,QAAQ;GACpB,MAAM,WAAY,IAAI;AAEtB,SAAM,KAAK,cAAc,SAAS;EACnC,EACF;CACF;CAED,MAAc,SACZC,OACA;EAEA,MAAM,SAAS,MAAM,KAAK,GAAG,MAAM;GACjC,OAAO,MAAM;GACb,UAAU,MAAM;GAChB,QAAQ,MAAM;EACf,EAAC;EAGF,MAAM,SAAS,MAAM,KAAK,GAAG,YAAY,OAAO;AAEhD,SAAO;CACR;CAED,IAAI,UAA4B;EAC9B,MAAM,UAAU,KAAK,SAAS,KAAK,KAAK;AAGxC,SAAO,0BAAM,QAAQ,CAClB,IAAI,KAAK,kBAAkB,CAAC,CAC5B,IAAI,KAAK,WAAW,CAAC,CACrB,IAAI,KAAK,OAAO,CAAC,CACjB,IAAI,KAAK,UAAU,CAAC,CACpB,IAAI,KAAK,OAAO,CAAC,CACjB,IAAI,KAAK,QAAQ,CAAC;CACtB;AACF"}

package/dist/AWSLambdaFunction-DSB2oaFG.d.mts

@@ -1,27 +0,0 @@
-import { Function, FunctionHandler } from "./Function-G3JPHMaY.mjs";
-import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-DHFMLrOl.mjs";
-import { Service } from "@geekmidas/services";
-import { EnvironmentParser } from "@geekmidas/envkit";
-import { EventPublisher } from "@geekmidas/events";
-import { Logger } from "@geekmidas/logger";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-import { ComposableStandardSchema } from "@geekmidas/schema";
-import { Handler } from "aws-lambda";
-
-//#region src/functions/AWSLambdaFunction.d.ts
-type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<TEvent, TResult>;
-declare 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> extends FunctionExecutionWrapper<TInput, TOutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName> {
-  readonly fn: Function<TInput, TServices, TLogger, TOutSchema, FunctionHandler<TInput, TServices, TLogger, TOutSchema>, TEventPublisher, TEventPublisherServiceName>;
-  constructor(envParser: EnvironmentParser<{}>, fn: Function<TInput, TServices, TLogger, TOutSchema, FunctionHandler<TInput, TServices, TLogger, TOutSchema>, TEventPublisher, TEventPublisherServiceName>);
-  private error;
-  private baseInput;
-  private input;
-  private loggerMiddleware;
-  private services;
-  private events;
-  private _handler;
-  get handler(): AWSLambdaHandler;
-}
-//#endregion
-export { AWSLambdaFunction, AWSLambdaHandler };
-//# sourceMappingURL=AWSLambdaFunction-DSB2oaFG.d.mts.map

package/dist/AWSLambdaFunction-cL8A169J.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AWSLambdaFunction-cL8A169J.mjs","names":["envParser: EnvironmentParser<{}>","fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >","event: FunctionEvent<TEvent, TInput, TServices, TLogger>"],"sources":["../src/functions/AWSLambdaFunction.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport middy, { type MiddlewareObj } from '@middy/core';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Context, Handler } from 'aws-lambda';\nimport type { Function, FunctionHandler } from './Function';\nimport { FunctionBuilder } from './FunctionBuilder';\n\nimport { wrapError } from '@geekmidas/errors';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n  ComposableStandardSchema,\n  InferComposableStandardSchema,\n  InferStandardSchema,\n} from '@geekmidas/schema';\nimport type { Service, ServiceRecord } from '@geekmidas/services';\nimport { FunctionExecutionWrapper } from './FunctionExecutionWrapper';\n\nexport type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<\n  TEvent,\n  TResult\n>;\n\ntype FunctionEvent<\n  TEvent,\n  TInput extends ComposableStandardSchema | undefined,\n  TServices extends Service[],\n  TLogger extends Logger,\n> = TEvent & {\n  parsedInput: InferComposableStandardSchema<TInput>;\n  services: ServiceRecord<TServices>;\n  logger: TLogger;\n};\n\ntype Middleware<\n  TEvent,\n  TInput extends ComposableStandardSchema | undefined,\n  TServices extends Service[],\n  TLogger extends Logger,\n  TOutSchema extends StandardSchemaV1 | undefined,\n> = MiddlewareObj<\n  FunctionEvent<TEvent, TInput, TServices, TLogger>,\n  InferComposableStandardSchema<TOutSchema>,\n  Error,\n  Context\n>;\n\nexport class AWSLambdaFunction<\n  TInput extends ComposableStandardSchema | undefined = undefined,\n  TOutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> extends FunctionExecutionWrapper<\n  TInput,\n  TOutSchema,\n  TServices,\n  TLogger,\n  TEventPublisher,\n  TEventPublisherServiceName\n> {\n  constructor(\n    envParser: EnvironmentParser<{}>,\n    readonly fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ) {\n    super(envParser, fn);\n  }\n\n  private error<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      onError: (req) => {\n        const logger = req.event?.logger || this.fn.logger;\n        logger.error(req.error || {}, 'Error processing function');\n\n        // Re-throw the wrapped error to let Lambda handle it\n        throw wrapError(req.error);\n      },\n    };\n  }\n\n  private baseInput<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: (req) => {},\n    };\n  }\n\n  private input<\n    TEvent extends { input: InferComposableStandardSchema<TInput> },\n  >(): Middleware<TEvent, TInput, TServices, TLogger, TOutSchema> {\n    return {\n      before: async (req) => {\n        try {\n          // Parse input if schema is provided\n          if (this.fn.input) {\n            const parsedInput =\n              await FunctionBuilder.parseComposableStandardSchema(\n                req.event,\n                this.fn.input,\n              );\n\n            req.event.parsedInput =\n              parsedInput as InferComposableStandardSchema<TInput>;\n          } else {\n            // If no schema, pass the event as-is\n            req.event.parsedInput = req.event as any;\n          }\n        } catch (error) {\n          this.logger.error(\n            { error, event: req.event },\n            'Failed to parse input',\n          );\n          throw error;\n        }\n      },\n    };\n  }\n\n  private loggerMiddleware<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: (req) => {\n        this._logger = this.fn.logger.child({\n          fn: {\n            name: req.context.functionName,\n            version: req.context.functionVersion,\n            memory: req.context.memoryLimitInMB,\n          },\n          req: {\n            id: req.context.awsRequestId,\n          },\n        }) as TLogger;\n\n        req.event.logger = this._logger;\n      },\n    };\n  }\n\n  private services<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      before: async (req) => {\n        req.event.services = await this.getServices();\n      },\n    };\n  }\n\n  private events<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema\n  > {\n    return {\n      after: async (req) => {\n        const response = (req.response ||\n          undefined) as InferStandardSchema<TOutSchema>;\n        await this.publishEvents(response);\n      },\n    };\n  }\n\n  private async _handler<TEvent>(\n    event: FunctionEvent<TEvent, TInput, TServices, TLogger>,\n  ) {\n    // Execute the function with the parsed context\n    const result = await this.fn['fn']({\n      input: event.parsedInput,\n      services: event.services,\n      logger: event.logger,\n    });\n\n    // Parse output if schema is provided\n    const output = await this.fn.parseOutput(result);\n\n    return output;\n  }\n\n  get handler(): AWSLambdaHandler {\n    const handler = this._handler.bind(this);\n\n    // Apply middleware in order\n    return middy(handler)\n      .use(this.loggerMiddleware())\n      .use(this.baseInput())\n      .use(this.error())\n      .use(this.services())\n      .use(this.input())\n      .use(this.events()) as unknown as AWSLambdaHandler;\n  }\n}\n"],"mappings":";;;;;;AA+CA,IAAa,oBAAb,cAOU,yBAOR;CACA,YACEA,WACSC,IAST;AACA,QAAM,WAAW,GAAG;EAVX;CAWV;CAED,AAAQ,QAMN;AACA,SAAO,EACL,SAAS,CAAC,QAAQ;GAChB,MAAM,SAAS,IAAI,OAAO,UAAU,KAAK,GAAG;AAC5C,UAAO,MAAM,IAAI,SAAS,CAAE,GAAE,4BAA4B;AAG1D,SAAM,UAAU,IAAI,MAAM;EAC3B,EACF;CACF;CAED,AAAQ,YAMN;AACA,SAAO,EACL,QAAQ,CAAC,QAAQ,CAAE,EACpB;CACF;CAED,AAAQ,QAEwD;AAC9D,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI;AAEF,QAAI,KAAK,GAAG,OAAO;KACjB,MAAM,cACJ,MAAM,gBAAgB,8BACpB,IAAI,OACJ,KAAK,GAAG,MACT;AAEH,SAAI,MAAM,cACR;IACH,MAEC,KAAI,MAAM,cAAc,IAAI;GAE/B,SAAQ,OAAO;AACd,SAAK,OAAO,MACV;KAAE;KAAO,OAAO,IAAI;IAAO,GAC3B,wBACD;AACD,UAAM;GACP;EACF,EACF;CACF;CAED,AAAQ,mBAMN;AACA,SAAO,EACL,QAAQ,CAAC,QAAQ;AACf,QAAK,UAAU,KAAK,GAAG,OAAO,MAAM;IAClC,IAAI;KACF,MAAM,IAAI,QAAQ;KAClB,SAAS,IAAI,QAAQ;KACrB,QAAQ,IAAI,QAAQ;IACrB;IACD,KAAK,EACH,IAAI,IAAI,QAAQ,aACjB;GACF,EAAC;AAEF,OAAI,MAAM,SAAS,KAAK;EACzB,EACF;CACF;CAED,AAAQ,WAMN;AACA,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI,MAAM,WAAW,MAAM,KAAK,aAAa;EAC9C,EACF;CACF;CAED,AAAQ,SAMN;AACA,SAAO,EACL,OAAO,OAAO,QAAQ;GACpB,MAAM,WAAY,IAAI;AAEtB,SAAM,KAAK,cAAc,SAAS;EACnC,EACF;CACF;CAED,MAAc,SACZC,OACA;EAEA,MAAM,SAAS,MAAM,KAAK,GAAG,MAAM;GACjC,OAAO,MAAM;GACb,UAAU,MAAM;GAChB,QAAQ,MAAM;EACf,EAAC;EAGF,MAAM,SAAS,MAAM,KAAK,GAAG,YAAY,OAAO;AAEhD,SAAO;CACR;CAED,IAAI,UAA4B;EAC9B,MAAM,UAAU,KAAK,SAAS,KAAK,KAAK;AAGxC,SAAO,MAAM,QAAQ,CAClB,IAAI,KAAK,kBAAkB,CAAC,CAC5B,IAAI,KAAK,WAAW,CAAC,CACrB,IAAI,KAAK,OAAO,CAAC,CACjB,IAAI,KAAK,UAAU,CAAC,CACpB,IAAI,KAAK,OAAO,CAAC,CACjB,IAAI,KAAK,QAAQ,CAAC;CACtB;AACF"}

package/dist/AWSLambdaFunction-t6q2o8EL.d.cts

@@ -1,27 +0,0 @@
-import { Function, FunctionHandler } from "./Function-6EWabl_X.cjs";
-import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-Ci-ookJG.cjs";
-import { EventPublisher } from "@geekmidas/events";
-import { Logger } from "@geekmidas/logger";
-import { Service } from "@geekmidas/services";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-import { ComposableStandardSchema } from "@geekmidas/schema";
-import { EnvironmentParser } from "@geekmidas/envkit";
-import { Handler } from "aws-lambda";
-
-//#region src/functions/AWSLambdaFunction.d.ts
-type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<TEvent, TResult>;
-declare 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> extends FunctionExecutionWrapper<TInput, TOutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName> {
-  readonly fn: Function<TInput, TServices, TLogger, TOutSchema, FunctionHandler<TInput, TServices, TLogger, TOutSchema>, TEventPublisher, TEventPublisherServiceName>;
-  constructor(envParser: EnvironmentParser<{}>, fn: Function<TInput, TServices, TLogger, TOutSchema, FunctionHandler<TInput, TServices, TLogger, TOutSchema>, TEventPublisher, TEventPublisherServiceName>);
-  private error;
-  private baseInput;
-  private input;
-  private loggerMiddleware;
-  private services;
-  private events;
-  private _handler;
-  get handler(): AWSLambdaHandler;
-}
-//#endregion
-export { AWSLambdaFunction, AWSLambdaHandler };
-//# sourceMappingURL=AWSLambdaFunction-t6q2o8EL.d.cts.map