@geekmidas/audit 0.0.1

package/dist/Auditor-CZ8lkASv.d.cts

@@ -0,0 +1,260 @@
+import { InferStandardSchema } from "@geekmidas/schema";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Represents an auditable action with a type and payload.
+ * Similar to PublishableMessage in @geekmidas/events.
+ *
+ * @template TType - The audit type/name (e.g., 'user.created')
+ * @template TPayload - The audit payload data
+ *
+ * @example
+ * ```typescript
+ * type AppAuditAction =
+ *   | AuditableAction<'user.created', { userId: string; email: string }>
+ *   | AuditableAction<'user.updated', { userId: string; changes: string[] }>
+ *   | AuditableAction<'order.placed', { orderId: string; total: number }>;
+ * ```
+ */
+type AuditableAction<TType extends string, TPayload = unknown> = {
+  type: TType;
+  payload: TPayload;
+};
+/**
+ * Extract the type string from an AuditableAction union.
+ */
+type ExtractAuditType<T extends AuditableAction<string, unknown>> = T extends AuditableAction<infer TType, unknown> ? TType : never;
+/**
+ * Extract the payload for a specific audit type from an AuditableAction union.
+ */
+type ExtractAuditPayload<T extends AuditableAction<string, unknown>, TType extends ExtractAuditType<T>> = T extends AuditableAction<TType, infer TPayload> ? TPayload : never;
+/**
+ * Audit operation types for database auditing.
+ */
+type AuditOperation = 'INSERT' | 'UPDATE' | 'DELETE' | 'CUSTOM';
+/**
+ * Represents the actor who performed an audited action.
+ */
+interface AuditActor {
+  /** Unique identifier for the actor (user ID, service ID, etc.) */
+  id?: string;
+  /** Type of actor ('user', 'system', 'service', etc.) */
+  type?: string;
+  /** Additional actor properties */
+  [key: string]: unknown;
+}
+/**
+ * Metadata associated with an audit record.
+ */
+interface AuditMetadata {
+  /** Request correlation ID */
+  requestId?: string;
+  /** Which endpoint was called */
+  endpoint?: string;
+  /** HTTP method */
+  method?: string;
+  /** Client IP address */
+  ip?: string;
+  /** Client user agent */
+  userAgent?: string;
+  /** Additional metadata */
+  [key: string]: unknown;
+}
+/**
+ * A complete audit record representing a tracked action.
+ */
+interface AuditRecord<TPayload = unknown> {
+  /** Unique identifier for this audit record */
+  id: string;
+  /** Audit type (e.g., 'user.created', 'order.placed') */
+  type: string;
+  /** Operation type for database audits */
+  operation: AuditOperation;
+  /** Database table name (for database operations) */
+  table?: string;
+  /** Entity primary key(s) */
+  entityId?: string | Record<string, unknown>;
+  /** Previous state (for UPDATE/DELETE) */
+  oldValues?: Record<string, unknown>;
+  /** New state (for INSERT/UPDATE) */
+  newValues?: Record<string, unknown>;
+  /** Custom payload (for CUSTOM operations) */
+  payload?: TPayload;
+  /** When the audit was recorded */
+  timestamp: Date;
+  /** Who performed the action */
+  actor?: AuditActor;
+  /** Request context */
+  metadata?: AuditMetadata;
+}
+/**
+ * Options for manual audit calls.
+ */
+interface AuditOptions {
+  /** Entity primary key(s) for easier querying */
+  entityId?: string | Record<string, unknown>;
+  /** Database table name */
+  table?: string;
+  /** Operation type (defaults to 'CUSTOM') */
+  operation?: AuditOperation;
+  /** Previous state */
+  oldValues?: Record<string, unknown>;
+  /** New state */
+  newValues?: Record<string, unknown>;
+}
+/**
+ * Mapped audit definition for declarative auditing.
+ * Similar to MappedEvent in @geekmidas/events.
+ */
+interface MappedAudit<TAuditAction extends AuditableAction<string, unknown>, TOutput extends StandardSchemaV1 | undefined = undefined> {
+  /** The audit type - must be a valid type from the AuditableAction union */
+  type: ExtractAuditType<TAuditAction>;
+  /** Function to extract payload from the response */
+  payload: (response: InferStandardSchema<TOutput>) => ExtractAuditPayload<TAuditAction, ExtractAuditType<TAuditAction>>;
+  /** Optional condition - only audit if this returns true */
+  when?: (response: InferStandardSchema<TOutput>) => boolean;
+  /** Optional entity ID extractor for easier querying */
+  entityId?: (response: InferStandardSchema<TOutput>) => string | Record<string, unknown>;
+  /** Optional table name for database association */
+  table?: string;
+}
+/**
+ * Extract the AuditableAction type from an Auditor.
+ */
+type ExtractAuditorAction<T> = T extends Auditor<infer A> ? A : never;
+//#endregion
+//#region src/Auditor.d.ts
+/**
+ * Interface for audit collection and flushing.
+ * Generic over audit action types for full type safety.
+ *
+ * @template TAuditAction - Union of all allowed audit action types
+ * @template TTransaction - Transaction type (e.g., Kysely Transaction)
+ *
+ * @example
+ * ```typescript
+ * type AppAuditAction =
+ *   | AuditableAction<'user.created', { userId: string; email: string }>
+ *   | AuditableAction<'user.updated', { userId: string; changes: string[] }>;
+ *
+ * // In endpoint handler
+ * const auditor: Auditor<AppAuditAction> = ...;
+ *
+ * // Type-safe audit calls
+ * auditor.audit('user.created', { userId: '123', email: 'test@example.com' }); // ✅
+ * auditor.audit('user.created', { orderId: '123' }); // ❌ Type error
+ * auditor.audit('unknown.type', {}); // ❌ Type error
+ * ```
+ */
+interface Auditor<TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>, TTransaction = unknown> {
+  /**
+   * The actor for all audits in this context.
+   * Set at construction time, immutable throughout the request.
+   */
+  readonly actor: AuditActor;
+  /**
+   * Record a type-safe audit entry.
+   * The payload type is inferred from the audit type.
+   *
+   * @param type - The audit type (must be a valid type from TAuditAction)
+   * @param payload - The audit payload (shape enforced by type)
+   * @param options - Optional audit metadata
+   *
+   * @example
+   * ```typescript
+   * auditor.audit('user.created', {
+   *   userId: '123',
+   *   email: 'test@example.com',
+   * });
+   *
+   * auditor.audit('order.placed', {
+   *   orderId: 'order-456',
+   *   total: 99.99,
+   * }, {
+   *   entityId: 'order-456',
+   *   table: 'orders',
+   * });
+   * ```
+   */
+  audit<TType extends ExtractAuditType<TAuditAction>>(type: TType, payload: ExtractAuditPayload<TAuditAction, TType>, options?: AuditOptions): void;
+  /**
+   * Record a raw audit record.
+   * Use this when you need full control over the audit structure,
+   * bypassing type safety.
+   *
+   * @param record - The audit record (id, timestamp, actor added automatically)
+   */
+  record(record: Omit<AuditRecord, 'id' | 'timestamp' | 'actor'>): void;
+  /**
+   * Get all collected audit records.
+   * Useful for inspection or custom processing.
+   */
+  getRecords(): AuditRecord[];
+  /**
+   * Flush all collected audits to storage.
+   * Called automatically by the endpoint adaptor inside the transaction.
+   *
+   * @param trx - Optional transaction context for atomic writes
+   */
+  flush(trx?: TTransaction): Promise<void>;
+  /**
+   * Clear all collected audit records without flushing.
+   * Use with caution - collected audits will be lost.
+   */
+  clear(): void;
+  /**
+   * Add metadata to all future audit records.
+   * Merges with existing metadata (new values override existing).
+   * Typically called by adaptors to add request context.
+   *
+   * @param metadata - Metadata to add (requestId, endpoint, method, ip, etc.)
+   *
+   * @example
+   * ```typescript
+   * // In endpoint adaptor
+   * auditor.addMetadata({
+   *   requestId: 'req-123',
+   *   endpoint: '/users',
+   *   method: 'POST',
+   *   ip: '192.168.1.1',
+   * });
+   * ```
+   */
+  addMetadata(metadata: AuditMetadata): void;
+  /**
+   * Set the transaction context for audit flushing.
+   * When set, flush() will use this transaction instead of requiring
+   * it to be passed explicitly. This enables declarative audits to
+   * participate in the same transaction as the handler's database operations.
+   *
+   * @param trx - The transaction context (e.g., Kysely Transaction)
+   *
+   * @example
+   * ```typescript
+   * // In handler with explicit transaction management
+   * const result = await withTransaction(services.database.raw, async (trx) => {
+   *   // Register transaction with auditor so declarative audits use it
+   *   auditor.setTransaction(trx);
+   *
+   *   const user = await trx.insertInto('users').values(data).returningAll().executeTakeFirstOrThrow();
+   *
+   *   // Manual audits will also use this transaction when flush() is called
+   *   auditor.audit('user.created', { userId: user.id });
+   *
+   *   return user;
+   * });
+   * // After handler, adaptor calls auditor.flush() which uses the stored transaction
+   * ```
+   */
+  setTransaction(trx: TTransaction): void;
+  /**
+   * Get the currently set transaction context.
+   * Returns undefined if no transaction has been set.
+   */
+  getTransaction(): TTransaction | undefined;
+}
+//#endregion
+export { AuditActor, AuditMetadata, AuditOperation, AuditOptions, AuditRecord, AuditableAction, Auditor, ExtractAuditPayload, ExtractAuditType, ExtractAuditorAction, MappedAudit };
+//# sourceMappingURL=Auditor-CZ8lkASv.d.cts.map

package/dist/Auditor-ii62d_pF.d.mts

@@ -0,0 +1,260 @@
+import { InferStandardSchema } from "@geekmidas/schema";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Represents an auditable action with a type and payload.
+ * Similar to PublishableMessage in @geekmidas/events.
+ *
+ * @template TType - The audit type/name (e.g., 'user.created')
+ * @template TPayload - The audit payload data
+ *
+ * @example
+ * ```typescript
+ * type AppAuditAction =
+ *   | AuditableAction<'user.created', { userId: string; email: string }>
+ *   | AuditableAction<'user.updated', { userId: string; changes: string[] }>
+ *   | AuditableAction<'order.placed', { orderId: string; total: number }>;
+ * ```
+ */
+type AuditableAction<TType extends string, TPayload = unknown> = {
+  type: TType;
+  payload: TPayload;
+};
+/**
+ * Extract the type string from an AuditableAction union.
+ */
+type ExtractAuditType<T extends AuditableAction<string, unknown>> = T extends AuditableAction<infer TType, unknown> ? TType : never;
+/**
+ * Extract the payload for a specific audit type from an AuditableAction union.
+ */
+type ExtractAuditPayload<T extends AuditableAction<string, unknown>, TType extends ExtractAuditType<T>> = T extends AuditableAction<TType, infer TPayload> ? TPayload : never;
+/**
+ * Audit operation types for database auditing.
+ */
+type AuditOperation = 'INSERT' | 'UPDATE' | 'DELETE' | 'CUSTOM';
+/**
+ * Represents the actor who performed an audited action.
+ */
+interface AuditActor {
+  /** Unique identifier for the actor (user ID, service ID, etc.) */
+  id?: string;
+  /** Type of actor ('user', 'system', 'service', etc.) */
+  type?: string;
+  /** Additional actor properties */
+  [key: string]: unknown;
+}
+/**
+ * Metadata associated with an audit record.
+ */
+interface AuditMetadata {
+  /** Request correlation ID */
+  requestId?: string;
+  /** Which endpoint was called */
+  endpoint?: string;
+  /** HTTP method */
+  method?: string;
+  /** Client IP address */
+  ip?: string;
+  /** Client user agent */
+  userAgent?: string;
+  /** Additional metadata */
+  [key: string]: unknown;
+}
+/**
+ * A complete audit record representing a tracked action.
+ */
+interface AuditRecord<TPayload = unknown> {
+  /** Unique identifier for this audit record */
+  id: string;
+  /** Audit type (e.g., 'user.created', 'order.placed') */
+  type: string;
+  /** Operation type for database audits */
+  operation: AuditOperation;
+  /** Database table name (for database operations) */
+  table?: string;
+  /** Entity primary key(s) */
+  entityId?: string | Record<string, unknown>;
+  /** Previous state (for UPDATE/DELETE) */
+  oldValues?: Record<string, unknown>;
+  /** New state (for INSERT/UPDATE) */
+  newValues?: Record<string, unknown>;
+  /** Custom payload (for CUSTOM operations) */
+  payload?: TPayload;
+  /** When the audit was recorded */
+  timestamp: Date;
+  /** Who performed the action */
+  actor?: AuditActor;
+  /** Request context */
+  metadata?: AuditMetadata;
+}
+/**
+ * Options for manual audit calls.
+ */
+interface AuditOptions {
+  /** Entity primary key(s) for easier querying */
+  entityId?: string | Record<string, unknown>;
+  /** Database table name */
+  table?: string;
+  /** Operation type (defaults to 'CUSTOM') */
+  operation?: AuditOperation;
+  /** Previous state */
+  oldValues?: Record<string, unknown>;
+  /** New state */
+  newValues?: Record<string, unknown>;
+}
+/**
+ * Mapped audit definition for declarative auditing.
+ * Similar to MappedEvent in @geekmidas/events.
+ */
+interface MappedAudit<TAuditAction extends AuditableAction<string, unknown>, TOutput extends StandardSchemaV1 | undefined = undefined> {
+  /** The audit type - must be a valid type from the AuditableAction union */
+  type: ExtractAuditType<TAuditAction>;
+  /** Function to extract payload from the response */
+  payload: (response: InferStandardSchema<TOutput>) => ExtractAuditPayload<TAuditAction, ExtractAuditType<TAuditAction>>;
+  /** Optional condition - only audit if this returns true */
+  when?: (response: InferStandardSchema<TOutput>) => boolean;
+  /** Optional entity ID extractor for easier querying */
+  entityId?: (response: InferStandardSchema<TOutput>) => string | Record<string, unknown>;
+  /** Optional table name for database association */
+  table?: string;
+}
+/**
+ * Extract the AuditableAction type from an Auditor.
+ */
+type ExtractAuditorAction<T> = T extends Auditor<infer A> ? A : never;
+//#endregion
+//#region src/Auditor.d.ts
+/**
+ * Interface for audit collection and flushing.
+ * Generic over audit action types for full type safety.
+ *
+ * @template TAuditAction - Union of all allowed audit action types
+ * @template TTransaction - Transaction type (e.g., Kysely Transaction)
+ *
+ * @example
+ * ```typescript
+ * type AppAuditAction =
+ *   | AuditableAction<'user.created', { userId: string; email: string }>
+ *   | AuditableAction<'user.updated', { userId: string; changes: string[] }>;
+ *
+ * // In endpoint handler
+ * const auditor: Auditor<AppAuditAction> = ...;
+ *
+ * // Type-safe audit calls
+ * auditor.audit('user.created', { userId: '123', email: 'test@example.com' }); // ✅
+ * auditor.audit('user.created', { orderId: '123' }); // ❌ Type error
+ * auditor.audit('unknown.type', {}); // ❌ Type error
+ * ```
+ */
+interface Auditor<TAuditAction extends AuditableAction<string, unknown> = AuditableAction<string, unknown>, TTransaction = unknown> {
+  /**
+   * The actor for all audits in this context.
+   * Set at construction time, immutable throughout the request.
+   */
+  readonly actor: AuditActor;
+  /**
+   * Record a type-safe audit entry.
+   * The payload type is inferred from the audit type.
+   *
+   * @param type - The audit type (must be a valid type from TAuditAction)
+   * @param payload - The audit payload (shape enforced by type)
+   * @param options - Optional audit metadata
+   *
+   * @example
+   * ```typescript
+   * auditor.audit('user.created', {
+   *   userId: '123',
+   *   email: 'test@example.com',
+   * });
+   *
+   * auditor.audit('order.placed', {
+   *   orderId: 'order-456',
+   *   total: 99.99,
+   * }, {
+   *   entityId: 'order-456',
+   *   table: 'orders',
+   * });
+   * ```
+   */
+  audit<TType extends ExtractAuditType<TAuditAction>>(type: TType, payload: ExtractAuditPayload<TAuditAction, TType>, options?: AuditOptions): void;
+  /**
+   * Record a raw audit record.
+   * Use this when you need full control over the audit structure,
+   * bypassing type safety.
+   *
+   * @param record - The audit record (id, timestamp, actor added automatically)
+   */
+  record(record: Omit<AuditRecord, 'id' | 'timestamp' | 'actor'>): void;
+  /**
+   * Get all collected audit records.
+   * Useful for inspection or custom processing.
+   */
+  getRecords(): AuditRecord[];
+  /**
+   * Flush all collected audits to storage.
+   * Called automatically by the endpoint adaptor inside the transaction.
+   *
+   * @param trx - Optional transaction context for atomic writes
+   */
+  flush(trx?: TTransaction): Promise<void>;
+  /**
+   * Clear all collected audit records without flushing.
+   * Use with caution - collected audits will be lost.
+   */
+  clear(): void;
+  /**
+   * Add metadata to all future audit records.
+   * Merges with existing metadata (new values override existing).
+   * Typically called by adaptors to add request context.
+   *
+   * @param metadata - Metadata to add (requestId, endpoint, method, ip, etc.)
+   *
+   * @example
+   * ```typescript
+   * // In endpoint adaptor
+   * auditor.addMetadata({
+   *   requestId: 'req-123',
+   *   endpoint: '/users',
+   *   method: 'POST',
+   *   ip: '192.168.1.1',
+   * });
+   * ```
+   */
+  addMetadata(metadata: AuditMetadata): void;
+  /**
+   * Set the transaction context for audit flushing.
+   * When set, flush() will use this transaction instead of requiring
+   * it to be passed explicitly. This enables declarative audits to
+   * participate in the same transaction as the handler's database operations.
+   *
+   * @param trx - The transaction context (e.g., Kysely Transaction)
+   *
+   * @example
+   * ```typescript
+   * // In handler with explicit transaction management
+   * const result = await withTransaction(services.database.raw, async (trx) => {
+   *   // Register transaction with auditor so declarative audits use it
+   *   auditor.setTransaction(trx);
+   *
+   *   const user = await trx.insertInto('users').values(data).returningAll().executeTakeFirstOrThrow();
+   *
+   *   // Manual audits will also use this transaction when flush() is called
+   *   auditor.audit('user.created', { userId: user.id });
+   *
+   *   return user;
+   * });
+   * // After handler, adaptor calls auditor.flush() which uses the stored transaction
+   * ```
+   */
+  setTransaction(trx: TTransaction): void;
+  /**
+   * Get the currently set transaction context.
+   * Returns undefined if no transaction has been set.
+   */
+  getTransaction(): TTransaction | undefined;
+}
+//#endregion
+export { AuditActor, AuditMetadata, AuditOperation, AuditOptions, AuditRecord, AuditableAction, Auditor, ExtractAuditPayload, ExtractAuditType, ExtractAuditorAction, MappedAudit };
+//# sourceMappingURL=Auditor-ii62d_pF.d.mts.map

package/dist/Auditor.d.cts

@@ -0,0 +1,2 @@
+import { Auditor } from "./Auditor-CZ8lkASv.cjs";
+export { Auditor };

package/dist/Auditor.d.mts

@@ -0,0 +1,2 @@
+import { Auditor } from "./Auditor-ii62d_pF.mjs";
+export { Auditor };

package/dist/DefaultAuditor-1HDUGMub.cjs

@@ -0,0 +1,124 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const nanoid = __toESM(require("nanoid"));
+
+//#region src/DefaultAuditor.ts
+/**
+* Default implementation of the Auditor interface.
+* Collects audit records in memory and flushes to storage.
+*
+* @template TAuditAction - Union of all allowed audit action types
+* @template TTransaction - Transaction type (e.g., Kysely Transaction)
+*
+* @example
+* ```typescript
+* const auditor = new DefaultAuditor<AppAuditAction>({
+*   actor: { id: 'user-123', type: 'user' },
+*   storage: auditStorage,
+*   metadata: { requestId: 'req-456', endpoint: '/users' },
+* });
+*
+* auditor.audit('user.created', { userId: '789', email: 'test@example.com' });
+*
+* // Flush inside transaction
+* await auditor.flush(trx);
+* ```
+*/
+var DefaultAuditor = class {
+	actor;
+	storage;
+	metadata;
+	generateId;
+	records = [];
+	transaction;
+	constructor(config) {
+		this.actor = config.actor;
+		this.storage = config.storage;
+		this.metadata = config.metadata;
+		this.generateId = config.generateId ?? (() => (0, nanoid.nanoid)());
+	}
+	audit(type, payload, options) {
+		const record = {
+			id: this.generateId(),
+			type,
+			operation: options?.operation ?? "CUSTOM",
+			table: options?.table,
+			entityId: options?.entityId,
+			oldValues: options?.oldValues,
+			newValues: options?.newValues,
+			payload,
+			timestamp: /* @__PURE__ */ new Date(),
+			actor: this.actor,
+			metadata: this.metadata
+		};
+		this.records.push(record);
+	}
+	record(record) {
+		const fullRecord = {
+			...record,
+			id: this.generateId(),
+			timestamp: /* @__PURE__ */ new Date(),
+			actor: this.actor,
+			metadata: this.metadata ? {
+				...this.metadata,
+				...record.metadata
+			} : record.metadata
+		};
+		this.records.push(fullRecord);
+	}
+	getRecords() {
+		return [...this.records];
+	}
+	async flush(trx) {
+		if (this.records.length === 0) return;
+		const recordsToFlush = [...this.records];
+		this.records = [];
+		const transactionToUse = trx ?? this.transaction;
+		await this.storage.write(recordsToFlush, transactionToUse);
+	}
+	setTransaction(trx) {
+		this.transaction = trx;
+	}
+	getTransaction() {
+		return this.transaction;
+	}
+	clear() {
+		this.records = [];
+	}
+	addMetadata(metadata) {
+		this.metadata = this.metadata ? {
+			...this.metadata,
+			...metadata
+		} : metadata;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'DefaultAuditor', {
+  enumerable: true,
+  get: function () {
+    return DefaultAuditor;
+  }
+});
+//# sourceMappingURL=DefaultAuditor-1HDUGMub.cjs.map

package/dist/DefaultAuditor-1HDUGMub.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultAuditor-1HDUGMub.cjs","names":["config: DefaultAuditorConfig","type: TType","payload: ExtractAuditPayload<TAuditAction, TType>","options?: AuditOptions","record: AuditRecord","record: Omit<AuditRecord, 'id' | 'timestamp' | 'actor'>","fullRecord: AuditRecord","trx?: TTransaction","trx: TTransaction","metadata: AuditMetadata"],"sources":["../src/DefaultAuditor.ts"],"sourcesContent":["import { nanoid } from 'nanoid';\nimport type { Auditor } from './Auditor';\nimport type { AuditStorage } from './storage';\nimport type {\n  AuditableAction,\n  AuditActor,\n  AuditMetadata,\n  AuditOptions,\n  AuditRecord,\n  ExtractAuditPayload,\n  ExtractAuditType,\n} from './types';\n\n/**\n * Configuration for DefaultAuditor.\n */\nexport interface DefaultAuditorConfig {\n  /** The actor performing audits (set at construction, immutable) */\n  actor: AuditActor;\n  /** Storage backend for persisting audits */\n  storage: AuditStorage;\n  /** Optional metadata to attach to all audits */\n  metadata?: AuditMetadata;\n  /** Optional custom ID generator (defaults to nanoid) */\n  generateId?: () => string;\n}\n\n/**\n * Default implementation of the Auditor interface.\n * Collects audit records in memory and flushes to storage.\n *\n * @template TAuditAction - Union of all allowed audit action types\n * @template TTransaction - Transaction type (e.g., Kysely Transaction)\n *\n * @example\n * ```typescript\n * const auditor = new DefaultAuditor<AppAuditAction>({\n *   actor: { id: 'user-123', type: 'user' },\n *   storage: auditStorage,\n *   metadata: { requestId: 'req-456', endpoint: '/users' },\n * });\n *\n * auditor.audit('user.created', { userId: '789', email: 'test@example.com' });\n *\n * // Flush inside transaction\n * await auditor.flush(trx);\n * ```\n */\nexport class DefaultAuditor<\n  TAuditAction extends AuditableAction<string, unknown> = AuditableAction<\n    string,\n    unknown\n  >,\n  TTransaction = unknown,\n> implements Auditor<TAuditAction, TTransaction>\n{\n  readonly actor: AuditActor;\n  private readonly storage: AuditStorage;\n  private metadata?: AuditMetadata;\n  private readonly generateId: () => string;\n  private records: AuditRecord[] = [];\n  private transaction?: TTransaction;\n\n  constructor(config: DefaultAuditorConfig) {\n    this.actor = config.actor;\n    this.storage = config.storage;\n    this.metadata = config.metadata;\n    this.generateId = config.generateId ?? (() => nanoid());\n  }\n\n  audit<TType extends ExtractAuditType<TAuditAction>>(\n    type: TType,\n    payload: ExtractAuditPayload<TAuditAction, TType>,\n    options?: AuditOptions,\n  ): void {\n    const record: AuditRecord = {\n      id: this.generateId(),\n      type,\n      operation: options?.operation ?? 'CUSTOM',\n      table: options?.table,\n      entityId: options?.entityId,\n      oldValues: options?.oldValues,\n      newValues: options?.newValues,\n      payload,\n      timestamp: new Date(),\n      actor: this.actor,\n      metadata: this.metadata,\n    };\n\n    this.records.push(record);\n  }\n\n  record(record: Omit<AuditRecord, 'id' | 'timestamp' | 'actor'>): void {\n    const fullRecord: AuditRecord = {\n      ...record,\n      id: this.generateId(),\n      timestamp: new Date(),\n      actor: this.actor,\n      metadata: this.metadata\n        ? { ...this.metadata, ...record.metadata }\n        : record.metadata,\n    };\n\n    this.records.push(fullRecord);\n  }\n\n  getRecords(): AuditRecord[] {\n    return [...this.records];\n  }\n\n  async flush(trx?: TTransaction): Promise<void> {\n    if (this.records.length === 0) {\n      return;\n    }\n\n    const recordsToFlush = [...this.records];\n    this.records = [];\n\n    // Use explicitly passed transaction, or fall back to stored transaction\n    const transactionToUse = trx ?? this.transaction;\n    await this.storage.write(recordsToFlush, transactionToUse);\n  }\n\n  setTransaction(trx: TTransaction): void {\n    this.transaction = trx;\n  }\n\n  getTransaction(): TTransaction | undefined {\n    return this.transaction;\n  }\n\n  clear(): void {\n    this.records = [];\n  }\n\n  addMetadata(metadata: AuditMetadata): void {\n    this.metadata = this.metadata\n      ? { ...this.metadata, ...metadata }\n      : metadata;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,IAAa,iBAAb,MAOA;CACE,AAAS;CACT,AAAiB;CACjB,AAAQ;CACR,AAAiB;CACjB,AAAQ,UAAyB,CAAE;CACnC,AAAQ;CAER,YAAYA,QAA8B;AACxC,OAAK,QAAQ,OAAO;AACpB,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,OAAO;AACvB,OAAK,aAAa,OAAO,eAAe,MAAM,oBAAQ;CACvD;CAED,MACEC,MACAC,SACAC,SACM;EACN,MAAMC,SAAsB;GAC1B,IAAI,KAAK,YAAY;GACrB;GACA,WAAW,SAAS,aAAa;GACjC,OAAO,SAAS;GAChB,UAAU,SAAS;GACnB,WAAW,SAAS;GACpB,WAAW,SAAS;GACpB;GACA,2BAAW,IAAI;GACf,OAAO,KAAK;GACZ,UAAU,KAAK;EAChB;AAED,OAAK,QAAQ,KAAK,OAAO;CAC1B;CAED,OAAOC,QAA+D;EACpE,MAAMC,aAA0B;GAC9B,GAAG;GACH,IAAI,KAAK,YAAY;GACrB,2BAAW,IAAI;GACf,OAAO,KAAK;GACZ,UAAU,KAAK,WACX;IAAE,GAAG,KAAK;IAAU,GAAG,OAAO;GAAU,IACxC,OAAO;EACZ;AAED,OAAK,QAAQ,KAAK,WAAW;CAC9B;CAED,aAA4B;AAC1B,SAAO,CAAC,GAAG,KAAK,OAAQ;CACzB;CAED,MAAM,MAAMC,KAAmC;AAC7C,MAAI,KAAK,QAAQ,WAAW,EAC1B;EAGF,MAAM,iBAAiB,CAAC,GAAG,KAAK,OAAQ;AACxC,OAAK,UAAU,CAAE;EAGjB,MAAM,mBAAmB,OAAO,KAAK;AACrC,QAAM,KAAK,QAAQ,MAAM,gBAAgB,iBAAiB;CAC3D;CAED,eAAeC,KAAyB;AACtC,OAAK,cAAc;CACpB;CAED,iBAA2C;AACzC,SAAO,KAAK;CACb;CAED,QAAc;AACZ,OAAK,UAAU,CAAE;CAClB;CAED,YAAYC,UAA+B;AACzC,OAAK,WAAW,KAAK,WACjB;GAAE,GAAG,KAAK;GAAU,GAAG;EAAU,IACjC;CACL;AACF"}