@geekmidas/constructs 0.0.11 → 0.0.13

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

@@ -373,4 +373,86 @@ describe('AWSLambdaFunction', () => {
   });
 
   // Skipping timeout tests for now as middleware order needs to be adjusted
+
+  describe('database', () => {
+    // Mock database service
+    class MockDatabase {
+      async query(sql: string) {
+        return [{ id: '1', name: 'Test User' }];
+      }
+    }
+
+    class DatabaseService implements Service<'database', MockDatabase> {
+      serviceName = 'database' as const;
+      db = new MockDatabase();
+
+      async register() {
+        return this.db;
+      }
+    }
+
+    it('should inject database into function context', async () => {
+      const databaseService = new DatabaseService();
+      const handler = vi.fn(async ({ db }) => {
+        const result = await db.query('SELECT * FROM users');
+        return { users: result };
+      });
+
+      const outputSchema = z.object({
+        users: z.array(z.object({ id: z.string(), name: z.string() })),
+      });
+
+      const fn = new Function(
+        handler,
+        undefined,
+        undefined,
+        undefined,
+        outputSchema,
+        [],
+        logger,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        databaseService,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const lambdaHandler = adaptor.handler;
+
+      const result = await lambdaHandler({}, createMockContext(), vi.fn());
+
+      expect(result).toEqual({ users: [{ id: '1', name: 'Test User' }] });
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          db: expect.any(MockDatabase),
+        }),
+      );
+    });
+
+    it('should have db as undefined when no database service is configured', async () => {
+      const handler = vi.fn(async ({ db }) => {
+        return { hasDb: db !== undefined };
+      });
+
+      const outputSchema = z.object({ hasDb: z.boolean() });
+
+      const fn = new Function(
+        handler,
+        undefined,
+        undefined,
+        undefined,
+        outputSchema,
+        [],
+        logger,
+      );
+
+      const adaptor = new AWSLambdaFunction(envParser, fn);
+      const lambdaHandler = adaptor.handler;
+
+      const result = await lambdaHandler({}, createMockContext(), vi.fn());
+
+      expect(result).toEqual({ hasDb: false });
+    });
+  });
 });

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

@@ -1,7 +1,21 @@
-import { describe, expect, it } from 'vitest';
+import type { AuditRecord, AuditStorage } from '@geekmidas/audit';
 import { ConsoleLogger } from '@geekmidas/logger/console';
-import { FunctionBuilder } from '../FunctionBuilder';
 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,
@@ -29,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', () => {
@@ -53,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([]);
     });
@@ -64,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 () => ({}));
@@ -130,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([]);
     });
   });
 
@@ -157,4 +177,31 @@ describe('FunctionBuilder - State Isolation', () => {
       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();
+    });
+  });
 });

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,