@geekmidas/constructs 0.0.11 → 0.0.13

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

@@ -1,15 +1,15 @@
+import type { AuditStorage } from '@geekmidas/audit';
+import type { EventPublisher, MappedEvent } from '@geekmidas/events';
 import type { Logger } from '@geekmidas/logger';
 import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import get from 'lodash.get';
-import { ConstructType } from '../Construct';
-
-import type { EventPublisher, MappedEvent } from '@geekmidas/events';
 import type {
   ComposableStandardSchema,
   InferComposableStandardSchema,
 } from '@geekmidas/schema';
+import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import get from 'lodash.get';
+import { ConstructType } from '../Construct';
 
 const DEFAULT_LOGGER = new ConsoleLogger() as any;
 
@@ -20,6 +20,10 @@ export abstract class BaseFunctionBuilder<
   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,
 > {
   protected inputSchema?: TInput;
   protected outputSchema?: OutSchema;
@@ -30,6 +34,8 @@ 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'];
@@ -92,7 +98,18 @@ export abstract class BaseFunctionBuilder<
 
   publisher<T extends EventPublisher<any>, TName extends string>(
     publisher: Service<TName, T>,
-  ): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName> {
+  ): BaseFunctionBuilder<
+    TInput,
+    OutSchema,
+    TServices,
+    TLogger,
+    T,
+    TName,
+    TAuditStorage,
+    TAuditStorageServiceName,
+    TDatabase,
+    TDatabaseServiceName
+  > {
     this._publisher = publisher as unknown as Service<
       TEventPublisherServiceName,
       TEventPublisher
@@ -104,6 +121,80 @@ export abstract class BaseFunctionBuilder<
       TServices,
       TLogger,
       T,
+      TName,
+      TAuditStorage,
+      TAuditStorageServiceName,
+      TDatabase,
+      TDatabaseServiceName
+    >;
+  }
+
+  auditor<T extends AuditStorage, TName extends string>(
+    storage: Service<TName, T>,
+  ): BaseFunctionBuilder<
+    TInput,
+    OutSchema,
+    TServices,
+    TLogger,
+    TEventPublisher,
+    TEventPublisherServiceName,
+    T,
+    TName,
+    TDatabase,
+    TDatabaseServiceName
+  > {
+    this._auditorStorage = storage as unknown as Service<
+      TAuditStorageServiceName,
+      TAuditStorage
+    >;
+
+    return this as unknown as BaseFunctionBuilder<
+      TInput,
+      OutSchema,
+      TServices,
+      TLogger,
+      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,9 +1,5 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import uniqBy from 'lodash.uniqby';
-
-import type { Service, ServiceRecord } from '@geekmidas/services';
-import { Construct, ConstructType } from '../Construct';
-
+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';
 import { ConsoleLogger } from '@geekmidas/logger/console';
@@ -12,9 +8,11 @@ import type {
   InferComposableStandardSchema,
   InferStandardSchema,
 } from '@geekmidas/schema';
-
-import { UnprocessableEntityError } from '@geekmidas/errors';
 import { parseSchema } from '@geekmidas/schema/parser';
+import type { Service, ServiceRecord } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import uniqBy from 'lodash.uniqby';
+import { Construct, ConstructType } from '../Construct';
 
 const DEFAULT_LOGGER = new ConsoleLogger() as any;
 
@@ -54,20 +52,41 @@ export class Function<
   TServices extends Service[] = [],
   TLogger extends Logger = Logger,
   OutSchema extends StandardSchemaV1 | undefined = undefined,
+  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
-  > = FunctionHandler<TInput, TServices, TLogger, OutSchema>,
-  TEventPublisher extends EventPublisher<any> | undefined = undefined,
-  TEventPublisherServiceName extends string = string,
+    OutSchema,
+    TDatabase,
+    TAuditStorage,
+    TAuditAction
+  > = FunctionHandler<
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema,
+    TDatabase,
+    TAuditStorage,
+    TAuditAction
+  >,
 > extends Construct<
   TLogger,
   TEventPublisherServiceName,
   TEventPublisher,
   OutSchema,
-  TServices
+  TServices,
+  TAuditStorageServiceName,
+  TAuditStorage
 > {
   __IS_FUNCTION__ = true;
 
@@ -134,6 +153,8 @@ export class Function<
     publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
     events: MappedEvent<TEventPublisher, OutSchema>[] = [],
     memorySize?: number,
+    auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
+    public databaseService?: Service<TDatabaseServiceName, TDatabase>,
   ) {
     super(
       type,
@@ -144,6 +165,7 @@ export class Function<
       outputSchema,
       timeout,
       memorySize,
+      auditorStorageService,
     );
   }
 }
@@ -153,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>;