@geekmidas/constructs 0.0.12 → 0.0.14

package/src/endpoints/processAudits.ts

@@ -1,8 +1,8 @@
 import type {
-  AuditableAction,
   AuditActor,
-  Auditor,
   AuditStorage,
+  AuditableAction,
+  Auditor,
 } from '@geekmidas/audit';
 import { DefaultAuditor } from '@geekmidas/audit';
 import { withAuditableTransaction } from '@geekmidas/audit/kysely';
@@ -10,7 +10,7 @@ import type { Logger } from '@geekmidas/logger';
 import type { InferStandardSchema } from '@geekmidas/schema';
 import type { Service, ServiceDiscovery } from '@geekmidas/services';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Endpoint, CookieFn, HeaderFn } from './Endpoint';
+import type { CookieFn, Endpoint, HeaderFn } from './Endpoint';
 import type { ActorExtractor, MappedAudit } from './audit';
 
 /**
@@ -68,7 +68,8 @@ export async function processEndpointAudits<
 
     // If we have an existing auditor (from handler context), we need to flush
     // any manual audits it collected, even if there are no declarative audits
-    const hasExistingRecords = existingAuditor && existingAuditor.getRecords().length > 0;
+    const hasExistingRecords =
+      existingAuditor && existingAuditor.getRecords().length > 0;
 
     // Skip if no declarative audits and no existing records to flush
     if (!audits?.length && !hasExistingRecords) {
@@ -105,7 +106,11 @@ export async function processEndpointAudits<
       if (endpoint.actorExtractor) {
         try {
           actor = await (
-            endpoint.actorExtractor as ActorExtractor<TServices, TSession, TLogger>
+            endpoint.actorExtractor as ActorExtractor<
+              TServices,
+              TSession,
+              TLogger
+            >
           )({
             services: ctx.services as any,
             session: ctx.session,
@@ -136,7 +141,10 @@ export async function processEndpointAudits<
 
         // Check when condition
         if (audit.when && !audit.when(response as any)) {
-          logger.debug({ audit: audit.type }, 'Audit skipped due to when condition');
+          logger.debug(
+            { audit: audit.type },
+            'Audit skipped due to when condition',
+          );
           continue;
         }
 
@@ -160,9 +168,10 @@ export async function processEndpointAudits<
     const recordCount = auditor.getRecords().length;
     if (recordCount > 0) {
       // Check if auditor has a stored transaction (for logging purposes)
-      const trx = 'getTransaction' in auditor
-        ? (auditor as { getTransaction(): unknown }).getTransaction()
-        : undefined;
+      const trx =
+        'getTransaction' in auditor
+          ? (auditor as { getTransaction(): unknown }).getTransaction()
+          : undefined;
       logger.debug(
         { auditCount: recordCount, hasTransaction: !!trx },
         'Flushing audits',
@@ -210,6 +219,8 @@ export async function createAuditContext<
     string,
     unknown
   >,
+  TDatabase = undefined,
+  TDatabaseServiceName extends string = string,
 >(
   endpoint: Endpoint<
     any,
@@ -223,7 +234,9 @@ export async function createAuditContext<
     any,
     TAuditStorage,
     TAuditStorageServiceName,
-    TAuditAction
+    TAuditAction,
+    TDatabase,
+    TDatabaseServiceName
   >,
   serviceDiscovery: ServiceDiscovery<any, any>,
   logger: TLogger,
@@ -308,21 +321,17 @@ export async function executeWithAuditTransaction<
 
   if (db) {
     // Wrap in transaction - audits are atomic with handler operations
-    return withAuditableTransaction(
-      db as any,
-      auditor as any,
-      async () => {
-        const response = await handler(auditor);
+    return withAuditableTransaction(db as any, auditor as any, async () => {
+      const response = await handler(auditor);
 
-        // Process declarative audits within the transaction
-        if (onComplete) {
-          await onComplete(response, auditor);
-        }
+      // Process declarative audits within the transaction
+      if (onComplete) {
+        await onComplete(response, auditor);
+      }
 
-        // Audits are flushed by withAuditableTransaction before commit
-        return response;
-      },
-    );
+      // Audits are flushed by withAuditableTransaction before commit
+      return response;
+    });
   }
 
   // No database - run handler and flush audits after

package/src/functions/AWSLambdaFunction.ts

@@ -1,3 +1,4 @@
+import type { AuditStorage, AuditableAction, Auditor } from '@geekmidas/audit';
 import type { EnvironmentParser } from '@geekmidas/envkit';
 import middy, { type MiddlewareObj } from '@middy/core';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
@@ -26,10 +27,17 @@ type FunctionEvent<
   TInput extends ComposableStandardSchema | undefined,
   TServices extends Service[],
   TLogger extends Logger,
+  TDatabase = undefined,
+  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
+    string,
+    unknown
+  >,
 > = TEvent & {
   parsedInput: InferComposableStandardSchema<TInput>;
   services: ServiceRecord<TServices>;
   logger: TLogger;
+  db: TDatabase | undefined;
+  auditor: Auditor<TAuditAction> | undefined;
 };
 
 type Middleware<
@@ -38,8 +46,13 @@ type Middleware<
   TServices extends Service[],
   TLogger extends Logger,
   TOutSchema extends StandardSchemaV1 | undefined,
+  TDatabase = undefined,
+  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
+    string,
+    unknown
+  >,
 > = MiddlewareObj<
-  FunctionEvent<TEvent, TInput, TServices, TLogger>,
+  FunctionEvent<TEvent, TInput, TServices, TLogger, TDatabase, TAuditAction>,
   InferComposableStandardSchema<TOutSchema>,
   Error,
   Context
@@ -52,13 +65,26 @@ export class AWSLambdaFunction<
   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
+  TEventPublisherServiceName,
+  TAuditStorage,
+  TAuditStorageServiceName,
+  TDatabase,
+  TDatabaseServiceName,
+  TAuditAction
 > {
   constructor(
     envParser: EnvironmentParser<{}>,
@@ -67,9 +93,22 @@ export class AWSLambdaFunction<
       TServices,
       TLogger,
       TOutSchema,
-      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuditStorage,
+      TAuditStorageServiceName,
+      TDatabase,
+      TDatabaseServiceName,
+      TAuditAction,
+      FunctionHandler<
+        TInput,
+        TServices,
+        TLogger,
+        TOutSchema,
+        TDatabase,
+        TAuditStorage,
+        TAuditAction
+      >
     >,
   ) {
     super(envParser, fn);
@@ -80,7 +119,9 @@ export class AWSLambdaFunction<
     TInput,
     TServices,
     TLogger,
-    TOutSchema
+    TOutSchema,
+    TDatabase,
+    TAuditAction
   > {
     return {
       onError: (req) => {
@@ -98,7 +139,9 @@ export class AWSLambdaFunction<
     TInput,
     TServices,
     TLogger,
-    TOutSchema
+    TOutSchema,
+    TDatabase,
+    TAuditAction
   > {
     return {
       before: (req) => {},
@@ -107,7 +150,15 @@ export class AWSLambdaFunction<
 
   private input<
     TEvent extends { input: InferComposableStandardSchema<TInput> },
-  >(): Middleware<TEvent, TInput, TServices, TLogger, TOutSchema> {
+  >(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema,
+    TDatabase,
+    TAuditAction
+  > {
     return {
       before: async (req) => {
         try {
@@ -141,7 +192,9 @@ export class AWSLambdaFunction<
     TInput,
     TServices,
     TLogger,
-    TOutSchema
+    TOutSchema,
+    TDatabase,
+    TAuditAction
   > {
     return {
       before: (req) => {
@@ -166,7 +219,9 @@ export class AWSLambdaFunction<
     TInput,
     TServices,
     TLogger,
-    TOutSchema
+    TOutSchema,
+    TDatabase,
+    TAuditAction
   > {
     return {
       before: async (req) => {
@@ -175,12 +230,59 @@ export class AWSLambdaFunction<
     };
   }
 
+  private database<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema,
+    TDatabase,
+    TAuditAction
+  > {
+    return {
+      before: async (req) => {
+        req.event.db = await this.getDatabase();
+      },
+    };
+  }
+
+  private auditor<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema,
+    TDatabase,
+    TAuditAction
+  > {
+    return {
+      before: async (req) => {
+        req.event.auditor = await this.createAuditor();
+      },
+      after: async (req) => {
+        // Flush any pending audits after successful execution
+        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();
+          }
+        }
+      },
+    };
+  }
+
   private events<TEvent>(): Middleware<
     TEvent,
     TInput,
     TServices,
     TLogger,
-    TOutSchema
+    TOutSchema,
+    TDatabase,
+    TAuditAction
   > {
     return {
       after: async (req) => {
@@ -192,14 +294,23 @@ export class AWSLambdaFunction<
   }
 
   private async _handler<TEvent>(
-    event: FunctionEvent<TEvent, TInput, TServices, TLogger>,
+    event: FunctionEvent<
+      TEvent,
+      TInput,
+      TServices,
+      TLogger,
+      TDatabase,
+      TAuditAction
+    >,
   ) {
     // Execute the function with the parsed context
     const result = await this.fn['fn']({
       input: event.parsedInput,
       services: event.services,
       logger: event.logger,
-    });
+      db: event.db,
+      auditor: event.auditor,
+    } as any);
 
     // Parse output if schema is provided
     const output = await this.fn.parseOutput(result);
@@ -216,6 +327,8 @@ export class AWSLambdaFunction<
       .use(this.baseInput())
       .use(this.error())
       .use(this.services())
+      .use(this.database())
+      .use(this.auditor())
       .use(this.input())
       .use(this.events()) as unknown as AWSLambdaHandler;
   }

package/src/functions/BaseFunctionBuilder.ts

@@ -22,6 +22,8 @@ export abstract class BaseFunctionBuilder<
   TEventPublisherServiceName extends string = string,
   TAuditStorage extends AuditStorage | undefined = undefined,
   TAuditStorageServiceName extends string = string,
+  TDatabase = undefined,
+  TDatabaseServiceName extends string = string,
 > {
   protected inputSchema?: TInput;
   protected outputSchema?: OutSchema;
@@ -33,6 +35,7 @@ export abstract class BaseFunctionBuilder<
   protected _events: MappedEvent<TEventPublisher, OutSchema>[] = [];
   protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
   protected _auditorStorage?: Service<TAuditStorageServiceName, TAuditStorage>;
+  protected _databaseService?: Service<TDatabaseServiceName, TDatabase>;
 
   static isStandardSchemaV1(s: unknown): s is StandardSchemaV1 {
     const schema = (s as StandardSchemaV1)['~standard'];
@@ -103,7 +106,9 @@ export abstract class BaseFunctionBuilder<
     T,
     TName,
     TAuditStorage,
-    TAuditStorageServiceName
+    TAuditStorageServiceName,
+    TDatabase,
+    TDatabaseServiceName
   > {
     this._publisher = publisher as unknown as Service<
       TEventPublisherServiceName,
@@ -118,7 +123,9 @@ export abstract class BaseFunctionBuilder<
       T,
       TName,
       TAuditStorage,
-      TAuditStorageServiceName
+      TAuditStorageServiceName,
+      TDatabase,
+      TDatabaseServiceName
     >;
   }
 
@@ -132,7 +139,9 @@ export abstract class BaseFunctionBuilder<
     TEventPublisher,
     TEventPublisherServiceName,
     T,
-    TName
+    TName,
+    TDatabase,
+    TDatabaseServiceName
   > {
     this._auditorStorage = storage as unknown as Service<
       TAuditStorageServiceName,
@@ -147,6 +156,45 @@ export abstract class BaseFunctionBuilder<
       TEventPublisher,
       TEventPublisherServiceName,
       T,
+      TName,
+      TDatabase,
+      TDatabaseServiceName
+    >;
+  }
+
+  /**
+   * Set the database service for this function.
+   * The database will be available in the handler context as `db`.
+   */
+  database<T, TName extends string>(
+    service: Service<TName, T>,
+  ): BaseFunctionBuilder<
+    TInput,
+    OutSchema,
+    TServices,
+    TLogger,
+    TEventPublisher,
+    TEventPublisherServiceName,
+    TAuditStorage,
+    TAuditStorageServiceName,
+    T,
+    TName
+  > {
+    this._databaseService = service as unknown as Service<
+      TDatabaseServiceName,
+      TDatabase
+    >;
+
+    return this as unknown as BaseFunctionBuilder<
+      TInput,
+      OutSchema,
+      TServices,
+      TLogger,
+      TEventPublisher,
+      TEventPublisherServiceName,
+      TAuditStorage,
+      TAuditStorageServiceName,
+      T,
       TName
     >;
   }

package/src/functions/Function.ts

@@ -1,4 +1,4 @@
-import type { AuditStorage } from '@geekmidas/audit';
+import type { AuditStorage, AuditableAction, Auditor } from '@geekmidas/audit';
 import { UnprocessableEntityError } from '@geekmidas/errors';
 import type { EventPublisher, MappedEvent } from '@geekmidas/events';
 import type { Logger } from '@geekmidas/logger';
@@ -52,16 +52,33 @@ export class Function<
   TServices extends Service[] = [],
   TLogger extends Logger = Logger,
   OutSchema extends StandardSchemaV1 | undefined = undefined,
-  Fn extends FunctionHandler<
-    TInput,
-    TServices,
-    TLogger,
-    OutSchema
-  > = FunctionHandler<TInput, TServices, TLogger, OutSchema>,
   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
+  >,
+  Fn extends FunctionHandler<
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema,
+    TDatabase,
+    TAuditStorage,
+    TAuditAction
+  > = FunctionHandler<
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema,
+    TDatabase,
+    TAuditStorage,
+    TAuditAction
+  >,
 > extends Construct<
   TLogger,
   TEventPublisherServiceName,
@@ -137,6 +154,7 @@ export class Function<
     events: MappedEvent<TEventPublisher, OutSchema>[] = [],
     memorySize?: number,
     auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
+    public databaseService?: Service<TDatabaseServiceName, TDatabase>,
   ) {
     super(
       type,
@@ -157,18 +175,64 @@ export type FunctionHandler<
   TServices extends Service[] = [],
   TLogger extends Logger = Logger,
   OutSchema extends StandardSchemaV1 | undefined = undefined,
+  TDatabase = undefined,
+  TAuditStorage extends AuditStorage | undefined = undefined,
+  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
+    string,
+    unknown
+  >,
 > = (
-  ctx: FunctionContext<TInput, TServices, TLogger>,
+  ctx: FunctionContext<
+    TInput,
+    TServices,
+    TLogger,
+    TDatabase,
+    TAuditStorage,
+    TAuditAction
+  >,
 ) => OutSchema extends StandardSchemaV1
   ? InferStandardSchema<OutSchema> | Promise<InferStandardSchema<OutSchema>>
   : any | Promise<any>;
 
+/**
+ * Conditional type that adds `db` property only when TDatabase is configured.
+ */
+type DatabaseContext<TDatabase> = TDatabase extends undefined
+  ? {}
+  : { db: TDatabase };
+
+/**
+ * Conditional auditor context - only present when audit storage is configured.
+ */
+type AuditorContext<
+  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
+    string,
+    unknown
+  >,
+  TAuditStorage = undefined,
+> = TAuditStorage extends undefined
+  ? {}
+  : {
+      /**
+       * Auditor instance for recording audit events.
+       * Only present when audit storage is configured on the function.
+       */
+      auditor: Auditor<TAuditAction>;
+    };
+
 export type FunctionContext<
   Input extends ComposableStandardSchema | undefined = undefined,
   TServices extends Service[] = [],
   TLogger extends Logger = Logger,
+  TDatabase = undefined,
+  TAuditStorage extends AuditStorage | undefined = undefined,
+  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
+    string,
+    unknown
+  >,
 > = {
   services: ServiceRecord<TServices>;
   logger: TLogger;
   input: InferComposableStandardSchema<Input>;
-};
+} & DatabaseContext<TDatabase> &
+  AuditorContext<TAuditAction, TAuditStorage>;