@geekmidas/constructs 0.0.12 → 0.0.14

package/README.md

@@ -12,6 +12,7 @@ A comprehensive framework for building type-safe HTTP endpoints, cloud functions
 - **Multiple Adapters**: AWS Lambda, API Gateway (v1/v2), and Hono support
 - **StandardSchema Validation**: Works with Zod, Valibot, and other validation libraries
 - **Event Publishing**: Integrated event publishing from any construct
+- **Audit Logging**: Transaction-aware audit system with automatic rollback support
 - **Rate Limiting**: Built-in rate limiting with configurable storage
 - **OpenAPI Integration**: Generate OpenAPI specifications from endpoints
 
@@ -318,6 +319,452 @@ export const createUser = e
   });
 ```
 
+### Database Context
+
+Inject a database instance directly into the handler context using `.database()`:
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import type { Service } from '@geekmidas/services';
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import { Kysely, PostgresDialect } from 'kysely';
+import { z } from 'zod';
+
+// Define a database service
+const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      url: get('DATABASE_URL').string()
+    })).parse();
+
+    return new Kysely<Database>({
+      dialect: new PostgresDialect({
+        connectionString: config.url
+      })
+    });
+  }
+} satisfies Service<'database', Kysely<Database>>;
+
+// Use .database() to inject db into context
+export const getUsers = e
+  .get('/users')
+  .output(z.array(userSchema))
+  .database(databaseService)
+  .handle(async ({ db }) => {
+    // db is always defined when .database() is called (not optional)
+    const users = await db
+      .selectFrom('users')
+      .selectAll()
+      .execute();
+
+    return users;
+  });
+```
+
+**Key features:**
+
+- **Type-safe**: `db` is only available in the context when `.database()` is called
+- **Non-optional**: Unlike `services.database`, `db` is always defined (not `undefined`)
+- **Automatic transaction**: When combined with `.auditor()` using `KyselyAuditStorage`, `db` is automatically the transaction
+
+#### Database with Audit Transactions
+
+When using both `.database()` and `.auditor()` with the same database, `db` is automatically the transaction - ensuring ACID compliance without any extra code:
+
+```typescript
+export const createUser = e
+  .post('/users')
+  .body(z.object({ name: z.string(), email: z.string().email() }))
+  .output(userSchema)
+  .database(databaseService)
+  .auditor(auditStorageService)
+  .handle(async ({ body, db }) => {
+    // db is automatically the transaction when auditor uses KyselyAuditStorage
+    // Both the user insert and audit records commit/rollback together
+    const user = await db
+      .insertInto('users')
+      .values({ id: crypto.randomUUID(), ...body })
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    return user;
+  });
+```
+
+**How it works:**
+- Without `.auditor()`: `db` is the raw database connection
+- With `.auditor()` using `KyselyAuditStorage` **with matching `databaseServiceName`**: `db` is automatically the transaction
+- With `.auditor()` using a different storage or different database: `db` remains the raw database
+
+For automatic transaction sharing, the audit storage must declare the same database service name:
+
+```typescript
+const auditStorageService = {
+  serviceName: 'auditStorage' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const db = await databaseService.register(envParser);
+    return new KyselyAuditStorage({
+      db,
+      tableName: 'audit_logs',
+      databaseServiceName: 'database', // Must match databaseService.serviceName
+    });
+  }
+};
+```
+
+### Audit Logging
+
+Add transaction-aware audit logging to track data changes. Audits run **inside** the same database transaction as your mutations, ensuring they're atomically committed or rolled back together.
+
+#### Setting Up Audit Storage
+
+First, create an audit storage service using `@geekmidas/audit`:
+
+```typescript
+import { KyselyAuditStorage } from '@geekmidas/audit/kysely';
+import type { Service } from '@geekmidas/services';
+import type { EnvironmentParser } from '@geekmidas/envkit';
+
+const auditStorageService = {
+  serviceName: 'auditStorage' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const db = await databaseService.register(envParser);
+    return new KyselyAuditStorage({
+      db,
+      tableName: 'audit_logs',
+      // Set this to enable automatic transaction sharing with .database()
+      databaseServiceName: databaseService.serviceName,
+    });
+  }
+} satisfies Service<'auditStorage', KyselyAuditStorage<Database>>;
+```
+
+#### Defining Audit Action Types
+
+Define type-safe audit actions for your application:
+
+```typescript
+import type { AuditableAction } from '@geekmidas/audit';
+
+type AppAuditAction =
+  | AuditableAction<'user.created', { userId: string; email: string }>
+  | AuditableAction<'user.updated', { userId: string; changes: string[] }>
+  | AuditableAction<'user.deleted', { userId: string; reason?: string }>
+  | AuditableAction<'order.placed', { orderId: string; total: number }>;
+```
+
+#### Declarative Audits
+
+Define audits declaratively on the endpoint - they're automatically recorded after successful handler execution:
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email()
+});
+
+export const createUser = e
+  .post('/users')
+  .body(z.object({ name: z.string(), email: z.string().email() }))
+  .output(userSchema)
+  .database(databaseService)
+  .auditor(auditStorageService)
+  // Optional: extract actor from request context
+  .actor(({ session, header }) => ({
+    id: session?.userId ?? 'anonymous',
+    type: session ? 'user' : 'anonymous',
+    ip: header('x-forwarded-for'),
+  }))
+  // Declarative audits - type-safe with AppAuditAction
+  .audit<AppAuditAction>([
+    {
+      type: 'user.created',
+      payload: (response) => ({
+        userId: response.id,
+        email: response.email,
+      }),
+      // Optional: only audit when condition is true
+      when: (response) => response.email !== 'system@example.com',
+      // Optional: link audit to entity for querying
+      entityId: (response) => response.id,
+      table: 'users',
+    },
+  ])
+  .handle(async ({ body, db }) => {
+    // db is automatically the transaction when auditor uses KyselyAuditStorage
+    const user = await db
+      .insertInto('users')
+      .values({ id: crypto.randomUUID(), ...body })
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    return user;
+  });
+```
+
+**Important**: When using `KyselyAuditStorage`, the adaptor wraps handler execution in a database transaction. The `db` in the context is automatically the transaction, so you can use it directly for ACID-compliant mutations.
+
+#### Manual Audits in Handlers
+
+For complex scenarios, use `ctx.auditor` to record audits manually within your handler:
+
+```typescript
+export const processOrder = e
+  .post('/orders')
+  .database(databaseService)
+  .services([paymentService])
+  .auditor(auditStorageService)
+  .actor(({ session }) => ({ id: session.userId, type: 'user' }))
+  .handle(async ({ body, db, services, auditor }) => {
+    // db is automatically the transaction when auditor uses KyselyAuditStorage
+    const order = await db
+      .insertInto('orders')
+      .values(body)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    // Manual audit for payment (external service call)
+    const payment = await services.payment.charge(order.total);
+    auditor.audit('payment.processed', {
+      orderId: order.id,
+      amount: order.total,
+      transactionId: payment.transactionId,
+    });
+
+    // Conditional audit for high-value orders
+    if (order.total > 10000) {
+      auditor.audit('order.high_value', {
+        orderId: order.id,
+        total: order.total,
+        requiresReview: true,
+      });
+    }
+
+    return order;
+  });
+```
+
+#### Combined Declarative and Manual Audits
+
+You can use both approaches together:
+
+```typescript
+export const updateUser = e
+  .put('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .body(z.object({ name: z.string().optional(), email: z.string().email().optional() }))
+  .output(userSchema)
+  .database(databaseService)
+  .auditor(auditStorageService)
+  .actor(({ session }) => ({ id: session.userId, type: 'user' }))
+  // Declarative audit - always runs on success
+  .audit<AppAuditAction>([
+    {
+      type: 'user.updated',
+      payload: (response) => ({
+        userId: response.id,
+        changes: ['profile'],
+      }),
+    },
+  ])
+  .handle(async ({ params, body, db, auditor }) => {
+    // db is automatically the transaction when auditor uses KyselyAuditStorage
+
+    // Fetch old values for comparison
+    const oldUser = await db
+      .selectFrom('users')
+      .where('id', '=', params.id)
+      .selectAll()
+      .executeTakeFirstOrThrow();
+
+    // Update user
+    const user = await db
+      .updateTable('users')
+      .set(body)
+      .where('id', '=', params.id)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    // Manual audit with old/new values for detailed change tracking
+    if (oldUser.email !== user.email) {
+      auditor.audit('user.email_changed', {
+        userId: user.id,
+        oldEmail: oldUser.email,
+        newEmail: user.email,
+      });
+    }
+
+    return user;
+  });
+```
+
+#### How Transaction Support Works
+
+When using `KyselyAuditStorage`, the adaptor automatically:
+
+1. **Creates an audit context** before handler execution
+2. **Wraps execution in a transaction** using `withAuditableTransaction`
+3. **Passes the auditor** to your handler via `ctx.auditor`
+4. **Processes declarative audits** after the handler succeeds
+5. **Flushes all audits** to storage inside the transaction
+6. **Commits or rolls back** - if the handler throws, both data and audits are rolled back
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Request Flow                              │
+├─────────────────────────────────────────────────────────────┤
+│  1. Create audit context (auditor + storage)                │
+│  2. BEGIN TRANSACTION                                        │
+│     ├── Execute handler (with ctx.auditor)                  │
+│     ├── Handler calls auditor.audit() for manual audits     │
+│     ├── Process declarative .audit() definitions            │
+│     ├── Flush all audit records to storage                  │
+│  3. COMMIT (or ROLLBACK if handler throws)                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+This ensures:
+- **Atomicity**: Audits are never written if the mutation fails
+- **Consistency**: No orphaned audit records for failed operations
+- **Rollback safety**: Manual audits recorded before a later error are also rolled back
+
+#### Audit Table Migration
+
+Create a Kysely migration for the audit table:
+
+```typescript
+// migrations/YYYYMMDDHHMMSS_create_audit_logs.ts
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('audit_logs')
+    .addColumn('id', 'varchar(32)', (col) => col.primaryKey())
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('operation', 'varchar', (col) => col.notNull())
+    .addColumn('table', 'varchar')
+    .addColumn('entity_id', 'varchar')
+    .addColumn('old_values', 'jsonb')
+    .addColumn('new_values', 'jsonb')
+    .addColumn('payload', 'jsonb')
+    .addColumn('timestamp', 'timestamp', (col) =>
+      col.defaultTo(sql`now()`).notNull(),
+    )
+    .addColumn('actor_id', 'varchar')
+    .addColumn('actor_type', 'varchar')
+    .addColumn('actor_data', 'jsonb')
+    .addColumn('metadata', 'jsonb')
+    .execute();
+
+  // Create indexes for common queries
+  await db.schema
+    .createIndex('idx_audit_logs_type')
+    .on('audit_logs')
+    .column('type')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_entity')
+    .on('audit_logs')
+    .column('entity_id')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_actor')
+    .on('audit_logs')
+    .column('actor_id')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_timestamp')
+    .on('audit_logs')
+    .column('timestamp')
+    .execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('audit_logs').execute();
+}
+```
+
+If using camelCase column names with Kysely's `CamelCasePlugin`:
+
+```typescript
+// migrations/YYYYMMDDHHMMSS_create_audit_logs.ts
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('auditLogs')
+    .addColumn('id', 'varchar(32)', (col) => col.primaryKey())
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('operation', 'varchar', (col) => col.notNull())
+    .addColumn('table', 'varchar')
+    .addColumn('entityId', 'varchar')
+    .addColumn('oldValues', 'jsonb')
+    .addColumn('newValues', 'jsonb')
+    .addColumn('payload', 'jsonb')
+    .addColumn('timestamp', 'timestamp', (col) =>
+      col.defaultTo(sql`now()`).notNull(),
+    )
+    .addColumn('actorId', 'varchar')
+    .addColumn('actorType', 'varchar')
+    .addColumn('actorData', 'jsonb')
+    .addColumn('metadata', 'jsonb')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_type')
+    .on('auditLogs')
+    .column('type')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_entity')
+    .on('auditLogs')
+    .column('entityId')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_actor')
+    .on('auditLogs')
+    .column('actorId')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_audit_logs_timestamp')
+    .on('auditLogs')
+    .column('timestamp')
+    .execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('auditLogs').execute();
+}
+```
+
+#### Querying Audit Records
+
+The `KyselyAuditStorage` provides a `query` method:
+
+```typescript
+// In a handler or service
+const audits = await auditStorage.query({
+  entityId: userId,
+  table: 'users',
+  limit: 50,
+  orderBy: 'timestamp',
+  orderDirection: 'desc',
+});
+```
+
 ### Rate Limiting
 
 Add rate limiting to endpoints:
@@ -603,6 +1050,7 @@ const envVars = await endpoint.getEnvironment();
 
 - [@geekmidas/services](../services) - Service discovery and dependency injection
 - [@geekmidas/events](../events) - Event publishing and subscription
+- [@geekmidas/audit](../audit) - Transaction-aware audit logging
 - [@geekmidas/logger](../logger) - Structured logging
 - [@geekmidas/envkit](../envkit) - Environment configuration
 - [@geekmidas/errors](../errors) - HTTP error classes

package/dist/AWSLambdaFunction-B-Oxr8qt.d.cts

@@ -0,0 +1,30 @@
+import { Function, FunctionHandler } from "./Function-VI1TB3Mh.cjs";
+import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-CwtwYozd.cjs";
+import { AuditStorage, AuditableAction } from "@geekmidas/audit";
+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, TAuditStorage extends AuditStorage | undefined = undefined, TAuditStorageServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string, TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>> extends FunctionExecutionWrapper<TInput, TOutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction> {
+  readonly fn: Function<TInput, TServices, TLogger, TOutSchema, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, TOutSchema, TDatabase, TAuditStorage, TAuditAction>>;
+  constructor(envParser: EnvironmentParser<{}>, fn: Function<TInput, TServices, TLogger, TOutSchema, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, TOutSchema, TDatabase, TAuditStorage, TAuditAction>>);
+  private error;
+  private baseInput;
+  private input;
+  private loggerMiddleware;
+  private services;
+  private database;
+  private auditor;
+  private events;
+  private _handler;
+  get handler(): AWSLambdaHandler;
+}
+//#endregion
+export { AWSLambdaFunction, AWSLambdaHandler };
+//# sourceMappingURL=AWSLambdaFunction-B-Oxr8qt.d.cts.map

package/dist/{AWSLambdaFunction-DMxScuaw.cjs → AWSLambdaFunction-C-fuCLA3.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_FunctionBuilder = require('./FunctionBuilder-_hMwZUof.cjs');
-const require_FunctionExecutionWrapper = require('./FunctionExecutionWrapper-sxJNTpuc.cjs');
+const require_FunctionBuilder = require('./FunctionBuilder-DXvG_XD-.cjs');
+const require_FunctionExecutionWrapper = require('./FunctionExecutionWrapper-DkNycmOh.cjs');
 const __geekmidas_errors = require_chunk.__toESM(require("@geekmidas/errors"));
 const __middy_core = require_chunk.__toESM(require("@middy/core"));
 
@@ -54,6 +54,27 @@ var AWSLambdaFunction = class extends require_FunctionExecutionWrapper.FunctionE
 			req.event.services = await this.getServices();
 		} };
 	}
+	database() {
+		return { before: async (req) => {
+			req.event.db = await this.getDatabase();
+		} };
+	}
+	auditor() {
+		return {
+			before: async (req) => {
+				req.event.auditor = await this.createAuditor();
+			},
+			after: async (req) => {
+				if (req.event.auditor) {
+					const records = req.event.auditor.getRecords();
+					if (records.length > 0) {
+						this.logger.debug({ auditCount: records.length }, "Flushing function audits");
+						await req.event.auditor.flush();
+					}
+				}
+			}
+		};
+	}
 	events() {
 		return { after: async (req) => {
 			const response = req.response || void 0;
@@ -64,14 +85,16 @@ var AWSLambdaFunction = class extends require_FunctionExecutionWrapper.FunctionE
 		const result = await this.fn["fn"]({
 			input: event.parsedInput,
 			services: event.services,
-			logger: event.logger
+			logger: event.logger,
+			db: event.db,
+			auditor: event.auditor
 		});
 		const output = await this.fn.parseOutput(result);
 		return output;
 	}
 	get handler() {
 		const handler = this._handler.bind(this);
-		return (0, __middy_core.default)(handler).use(this.loggerMiddleware()).use(this.baseInput()).use(this.error()).use(this.services()).use(this.input()).use(this.events());
+		return (0, __middy_core.default)(handler).use(this.loggerMiddleware()).use(this.baseInput()).use(this.error()).use(this.services()).use(this.database()).use(this.auditor()).use(this.input()).use(this.events());
 	}
 };
 
@@ -82,4 +105,4 @@ Object.defineProperty(exports, 'AWSLambdaFunction', {
     return AWSLambdaFunction;
   }
 });
-//# sourceMappingURL=AWSLambdaFunction-DMxScuaw.cjs.map
+//# sourceMappingURL=AWSLambdaFunction-C-fuCLA3.cjs.map

package/dist/AWSLambdaFunction-C-fuCLA3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AWSLambdaFunction-C-fuCLA3.cjs","names":["FunctionExecutionWrapper","envParser: EnvironmentParser<{}>","fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      TEventPublisher,\n      TEventPublisherServiceName,\n      TAuditStorage,\n      TAuditStorageServiceName,\n      TDatabase,\n      TDatabaseServiceName,\n      TAuditAction,\n      FunctionHandler<\n        TInput,\n        TServices,\n        TLogger,\n        TOutSchema,\n        TDatabase,\n        TAuditStorage,\n        TAuditAction\n      >\n    >","event: FunctionEvent<\n      TEvent,\n      TInput,\n      TServices,\n      TLogger,\n      TDatabase,\n      TAuditAction\n    >"],"sources":["../src/functions/AWSLambdaFunction.ts"],"sourcesContent":["import type { AuditStorage, AuditableAction, Auditor } from '@geekmidas/audit';\nimport 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  TDatabase = undefined,\n  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<\n    string,\n    unknown\n  >,\n> = TEvent & {\n  parsedInput: InferComposableStandardSchema<TInput>;\n  services: ServiceRecord<TServices>;\n  logger: TLogger;\n  db: TDatabase | undefined;\n  auditor: Auditor<TAuditAction> | undefined;\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  TDatabase = undefined,\n  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<\n    string,\n    unknown\n  >,\n> = MiddlewareObj<\n  FunctionEvent<TEvent, TInput, TServices, TLogger, TDatabase, TAuditAction>,\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  TAuditStorage extends AuditStorage | undefined = undefined,\n  TAuditStorageServiceName extends string = string,\n  TDatabase = undefined,\n  TDatabaseServiceName extends string = string,\n  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<\n    string,\n    unknown\n  >,\n> extends FunctionExecutionWrapper<\n  TInput,\n  TOutSchema,\n  TServices,\n  TLogger,\n  TEventPublisher,\n  TEventPublisherServiceName,\n  TAuditStorage,\n  TAuditStorageServiceName,\n  TDatabase,\n  TDatabaseServiceName,\n  TAuditAction\n> {\n  constructor(\n    envParser: EnvironmentParser<{}>,\n    readonly fn: Function<\n      TInput,\n      TServices,\n      TLogger,\n      TOutSchema,\n      TEventPublisher,\n      TEventPublisherServiceName,\n      TAuditStorage,\n      TAuditStorageServiceName,\n      TDatabase,\n      TDatabaseServiceName,\n      TAuditAction,\n      FunctionHandler<\n        TInput,\n        TServices,\n        TLogger,\n        TOutSchema,\n        TDatabase,\n        TAuditStorage,\n        TAuditAction\n      >\n    >,\n  ) {\n    super(envParser, fn);\n  }\n\n  private error<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema,\n    TDatabase,\n    TAuditAction\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    TDatabase,\n    TAuditAction\n  > {\n    return {\n      before: (req) => {},\n    };\n  }\n\n  private input<\n    TEvent extends { input: InferComposableStandardSchema<TInput> },\n  >(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema,\n    TDatabase,\n    TAuditAction\n  > {\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    TDatabase,\n    TAuditAction\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    TDatabase,\n    TAuditAction\n  > {\n    return {\n      before: async (req) => {\n        req.event.services = await this.getServices();\n      },\n    };\n  }\n\n  private database<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema,\n    TDatabase,\n    TAuditAction\n  > {\n    return {\n      before: async (req) => {\n        req.event.db = await this.getDatabase();\n      },\n    };\n  }\n\n  private auditor<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema,\n    TDatabase,\n    TAuditAction\n  > {\n    return {\n      before: async (req) => {\n        req.event.auditor = await this.createAuditor();\n      },\n      after: async (req) => {\n        // Flush any pending audits after successful execution\n        if (req.event.auditor) {\n          const records = req.event.auditor.getRecords();\n          if (records.length > 0) {\n            this.logger.debug(\n              { auditCount: records.length },\n              'Flushing function audits',\n            );\n            await req.event.auditor.flush();\n          }\n        }\n      },\n    };\n  }\n\n  private events<TEvent>(): Middleware<\n    TEvent,\n    TInput,\n    TServices,\n    TLogger,\n    TOutSchema,\n    TDatabase,\n    TAuditAction\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<\n      TEvent,\n      TInput,\n      TServices,\n      TLogger,\n      TDatabase,\n      TAuditAction\n    >,\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      db: event.db,\n      auditor: event.auditor,\n    } as any);\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.database())\n      .use(this.auditor())\n      .use(this.input())\n      .use(this.events()) as unknown as AWSLambdaHandler;\n  }\n}\n"],"mappings":";;;;;;;AA4DA,IAAa,oBAAb,cAeUA,0DAYR;CACA,YACEC,WACSC,IAsBT;AACA,QAAM,WAAW,GAAG;EAvBX;CAwBV;CAED,AAAQ,QAQN;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,YAQN;AACA,SAAO,EACL,QAAQ,CAAC,QAAQ,CAAE,EACpB;CACF;CAED,AAAQ,QAUN;AACA,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,mBAQN;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,WAQN;AACA,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI,MAAM,WAAW,MAAM,KAAK,aAAa;EAC9C,EACF;CACF;CAED,AAAQ,WAQN;AACA,SAAO,EACL,QAAQ,OAAO,QAAQ;AACrB,OAAI,MAAM,KAAK,MAAM,KAAK,aAAa;EACxC,EACF;CACF;CAED,AAAQ,UAQN;AACA,SAAO;GACL,QAAQ,OAAO,QAAQ;AACrB,QAAI,MAAM,UAAU,MAAM,KAAK,eAAe;GAC/C;GACD,OAAO,OAAO,QAAQ;AAEpB,QAAI,IAAI,MAAM,SAAS;KACrB,MAAM,UAAU,IAAI,MAAM,QAAQ,YAAY;AAC9C,SAAI,QAAQ,SAAS,GAAG;AACtB,WAAK,OAAO,MACV,EAAE,YAAY,QAAQ,OAAQ,GAC9B,2BACD;AACD,YAAM,IAAI,MAAM,QAAQ,OAAO;KAChC;IACF;GACF;EACF;CACF;CAED,AAAQ,SAQN;AACA,SAAO,EACL,OAAO,OAAO,QAAQ;GACpB,MAAM,WAAY,IAAI;AAEtB,SAAM,KAAK,cAAc,SAAS;EACnC,EACF;CACF;CAED,MAAc,SACZC,OAQA;EAEA,MAAM,SAAS,MAAM,KAAK,GAAG,MAAM;GACjC,OAAO,MAAM;GACb,UAAU,MAAM;GAChB,QAAQ,MAAM;GACd,IAAI,MAAM;GACV,SAAS,MAAM;EAChB,EAAQ;EAGT,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,UAAU,CAAC,CACpB,IAAI,KAAK,SAAS,CAAC,CACnB,IAAI,KAAK,OAAO,CAAC,CACjB,IAAI,KAAK,QAAQ,CAAC;CACtB;AACF"}

package/dist/AWSLambdaFunction-CAm9r5ZX.d.mts

@@ -0,0 +1,30 @@
+import { Function, FunctionHandler } from "./Function-V9M9UVHp.mjs";
+import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-rhbIYT0Q.mjs";
+import { Service } from "@geekmidas/services";
+import { AuditStorage, AuditableAction } from "@geekmidas/audit";
+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, TAuditStorage extends AuditStorage | undefined = undefined, TAuditStorageServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string, TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>> extends FunctionExecutionWrapper<TInput, TOutSchema, TServices, TLogger, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction> {
+  readonly fn: Function<TInput, TServices, TLogger, TOutSchema, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, TOutSchema, TDatabase, TAuditStorage, TAuditAction>>;
+  constructor(envParser: EnvironmentParser<{}>, fn: Function<TInput, TServices, TLogger, TOutSchema, TEventPublisher, TEventPublisherServiceName, TAuditStorage, TAuditStorageServiceName, TDatabase, TDatabaseServiceName, TAuditAction, FunctionHandler<TInput, TServices, TLogger, TOutSchema, TDatabase, TAuditStorage, TAuditAction>>);
+  private error;
+  private baseInput;
+  private input;
+  private loggerMiddleware;
+  private services;
+  private database;
+  private auditor;
+  private events;
+  private _handler;
+  get handler(): AWSLambdaHandler;
+}
+//#endregion
+export { AWSLambdaFunction, AWSLambdaHandler };
+//# sourceMappingURL=AWSLambdaFunction-CAm9r5ZX.d.mts.map

package/dist/{AWSLambdaFunction-cL8A169J.mjs → AWSLambdaFunction-H65WfXLt.mjs}

@@ -1,5 +1,5 @@
-import { FunctionBuilder } from "./FunctionBuilder-CMhLQ4dt.mjs";
-import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-i9v5L3Av.mjs";
+import { FunctionBuilder } from "./FunctionBuilder-CVT7bG2o.mjs";
+import { FunctionExecutionWrapper } from "./FunctionExecutionWrapper-Bubnr0zA.mjs";
 import { wrapError } from "@geekmidas/errors";
 import middy from "@middy/core";
 
@@ -53,6 +53,27 @@ var AWSLambdaFunction = class extends FunctionExecutionWrapper {
 			req.event.services = await this.getServices();
 		} };
 	}
+	database() {
+		return { before: async (req) => {
+			req.event.db = await this.getDatabase();
+		} };
+	}
+	auditor() {
+		return {
+			before: async (req) => {
+				req.event.auditor = await this.createAuditor();
+			},
+			after: async (req) => {
+				if (req.event.auditor) {
+					const records = req.event.auditor.getRecords();
+					if (records.length > 0) {
+						this.logger.debug({ auditCount: records.length }, "Flushing function audits");
+						await req.event.auditor.flush();
+					}
+				}
+			}
+		};
+	}
 	events() {
 		return { after: async (req) => {
 			const response = req.response || void 0;
@@ -63,17 +84,19 @@ var AWSLambdaFunction = class extends FunctionExecutionWrapper {
 		const result = await this.fn["fn"]({
 			input: event.parsedInput,
 			services: event.services,
-			logger: event.logger
+			logger: event.logger,
+			db: event.db,
+			auditor: event.auditor
 		});
 		const output = await this.fn.parseOutput(result);
 		return output;
 	}
 	get handler() {
 		const handler = this._handler.bind(this);
-		return middy(handler).use(this.loggerMiddleware()).use(this.baseInput()).use(this.error()).use(this.services()).use(this.input()).use(this.events());
+		return middy(handler).use(this.loggerMiddleware()).use(this.baseInput()).use(this.error()).use(this.services()).use(this.database()).use(this.auditor()).use(this.input()).use(this.events());
 	}
 };
 
 //#endregion
 export { AWSLambdaFunction };
-//# sourceMappingURL=AWSLambdaFunction-cL8A169J.mjs.map
+//# sourceMappingURL=AWSLambdaFunction-H65WfXLt.mjs.map