@nest-toolbox/typeorm-audit-log 1.8.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 bogdanlupu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,283 @@
+# @nest-toolbox/typeorm-audit-log
+
+Automatic audit logging for TypeORM entities with user attribution, diff tracking, and queryable audit trails.
+
+[![npm version](https://badge.fury.io/js/%40nest-toolbox%2Ftypeorm-audit-log.svg)](https://www.npmjs.com/package/@nest-toolbox/typeorm-audit-log)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔄 **Automatic tracking** - Entity changes logged via TypeORM subscribers
+- 👤 **User attribution** - Captures who made each change via AsyncLocalStorage
+- 📊 **Diff calculation** - Shows exactly what changed between old and new values
+- 🔍 **Queryable history** - Find audit logs by entity, user, or time range
+- 🛡️ **Field exclusions** - Skip sensitive fields like passwords
+- ⚡ **Async mode** - Non-blocking audit writes for performance
+- 🎯 **Selective auditing** - Only track entities you care about
+
+## Installation
+
+```bash
+npm install @nest-toolbox/typeorm-audit-log
+```
+
+## Quick Start
+
+### 1. Import the module
+
+```typescript
+// app.module.ts
+import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AuditLogModule, AuditContextMiddleware } from '@nest-toolbox/typeorm-audit-log';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      // ... your database config
+    }),
+    AuditLogModule.forRoot({
+      retentionDays: 90,
+      excludeFields: ['password', 'refreshToken'],
+    }),
+  ],
+})
+export class AppModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    // Required: captures user context for audit logs
+    consumer.apply(AuditContextMiddleware).forRoutes('*');
+  }
+}
+```
+
+### 2. Mark entities as auditable
+
+```typescript
+// user.entity.ts
+import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
+import { Auditable } from '@nest-toolbox/typeorm-audit-log';
+
+@Entity()
+@Auditable()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column()
+  email: string;
+
+  @Column()
+  role: string;
+}
+```
+
+That's it! All INSERT, UPDATE, and DELETE operations on `User` will be automatically logged.
+
+## Configuration
+
+### Module Options
+
+```typescript
+AuditLogModule.forRoot({
+  // Days to keep audit logs (0 = forever)
+  retentionDays: 90,
+
+  // Fields to exclude from all audit logs
+  excludeFields: ['password', 'token', 'secret'],
+
+  // Entity names to exclude from auditing
+  excludeEntities: ['Session', 'Cache'],
+
+  // Don't block on audit writes (fire-and-forget)
+  async: false,
+});
+```
+
+### Async Configuration
+
+```typescript
+AuditLogModule.forRootAsync({
+  imports: [ConfigModule],
+  useFactory: (config: ConfigService) => ({
+    retentionDays: config.get('AUDIT_RETENTION_DAYS'),
+    async: config.get('AUDIT_ASYNC') === 'true',
+    excludeFields: config.get('AUDIT_EXCLUDE_FIELDS')?.split(',') || [],
+  }),
+  inject: [ConfigService],
+});
+```
+
+### Entity Options
+
+```typescript
+@Entity()
+@Auditable({
+  // Custom name in audit logs (default: class name)
+  entityName: 'UserAccount',
+
+  // Fields to exclude for this entity only
+  excludeFields: ['lastLoginAt', 'sessionData'],
+})
+export class User {
+  // ...
+}
+```
+
+## Querying Audit Logs
+
+Inject `AuditLogService` to query the audit trail:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { AuditLogService } from '@nest-toolbox/typeorm-audit-log';
+
+@Injectable()
+export class AuditService {
+  constructor(private auditLogService: AuditLogService) {}
+
+  // Get history for a specific entity
+  async getEntityHistory(entityName: string, entityId: string) {
+    return this.auditLogService.findByEntity(entityName, entityId);
+  }
+
+  // Get all changes by a user
+  async getUserActivity(userId: string) {
+    return this.auditLogService.findByUser(userId, {
+      since: new Date(Date.now() - 24 * 60 * 60 * 1000), // Last 24h
+    });
+  }
+
+  // Search all audit logs with filters
+  async searchAuditLogs() {
+    return this.auditLogService.findAll({
+      entityName: 'User',
+      action: 'UPDATE',
+      since: new Date('2024-01-01'),
+      page: 1,
+      limit: 50,
+    });
+  }
+}
+```
+
+## Manual Context Setting
+
+For non-HTTP contexts (queues, cron jobs, CLI), set the audit context manually:
+
+```typescript
+import { AuditContext } from '@nest-toolbox/typeorm-audit-log';
+
+@Injectable()
+export class OrderProcessor {
+  @Process('process-order')
+  async processOrder(job: Job) {
+    await AuditContext.run(
+      {
+        userId: 'system',
+        userName: 'Order Processor',
+        metadata: { jobId: job.id },
+      },
+      async () => {
+        // All entity changes here will be attributed to "system"
+        await this.orderService.updateStatus(job.data.orderId, 'processed');
+      },
+    );
+  }
+}
+```
+
+## Custom Context Extraction
+
+Customize how user info is extracted from requests:
+
+```typescript
+import { AuditContextMiddleware, createAuditContextMiddleware } from '@nest-toolbox/typeorm-audit-log';
+
+// Custom extractor for JWT claims
+const customMiddleware = createAuditContextMiddleware((req) => ({
+  userId: req.user?.sub,
+  userName: req.user?.preferred_username,
+  ip: req.headers['x-forwarded-for'] as string || req.ip,
+  userAgent: req.headers['user-agent'],
+  metadata: {
+    tenantId: req.headers['x-tenant-id'],
+  },
+}));
+
+// In your module
+consumer.apply(customMiddleware.use.bind(customMiddleware)).forRoutes('*');
+```
+
+## Audit Log Entry Structure
+
+Each audit log entry contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | UUID | Unique identifier |
+| `entityName` | string | Name of the entity |
+| `entityId` | string | Primary key of the entity |
+| `action` | enum | CREATE, UPDATE, or DELETE |
+| `userId` | string | ID of the user who made the change |
+| `userName` | string | Name/email of the user |
+| `oldValues` | JSON | Previous values (UPDATE/DELETE) |
+| `newValues` | JSON | New values (CREATE/UPDATE) |
+| `diff` | JSON | Array of changed fields |
+| `ip` | string | IP address of the request |
+| `userAgent` | string | Browser/client user agent |
+| `metadata` | JSON | Custom metadata |
+| `timestamp` | Date | When the change occurred |
+
+## Database Migration
+
+The module will create an `audit_logs` table. If you need to create it manually:
+
+```sql
+CREATE TABLE audit_logs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  entity_name VARCHAR(255) NOT NULL,
+  entity_id VARCHAR(255) NOT NULL,
+  action VARCHAR(10) NOT NULL,
+  user_id VARCHAR(255),
+  user_name VARCHAR(255),
+  old_values JSONB,
+  new_values JSONB,
+  diff JSONB,
+  metadata JSONB,
+  ip VARCHAR(45),
+  user_agent VARCHAR(500),
+  timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_audit_entity ON audit_logs(entity_name, entity_id);
+CREATE INDEX idx_audit_user ON audit_logs(user_id);
+CREATE INDEX idx_audit_timestamp ON audit_logs(timestamp);
+```
+
+## API Reference
+
+### Decorators
+
+- `@Auditable(options?)` - Mark an entity for audit logging
+- `@AuditIgnore()` - Exclude a field from audit logs (Phase 2)
+- `@AuditMask()` - Mask a field value in audit logs (Phase 2)
+
+### Services
+
+- `AuditLogService.log(params)` - Manually log an audit entry
+- `AuditLogService.findByEntity(name, id, options?)` - Query by entity
+- `AuditLogService.findByUser(userId, options?)` - Query by user
+- `AuditLogService.findAll(options?)` - Paginated search
+
+### Context
+
+- `AuditContext.run(data, fn)` - Run code with audit context
+- `AuditContext.get()` - Get current audit context
+- `AuditContext.set(data)` - Update current audit context
+
+## License
+
+MIT © [Bogdan Lupu](https://github.com/lupu60)

package/dist/audit-context.d.ts

@@ -0,0 +1,67 @@
+import type { AuditContextData } from './types';
+/**
+ * Run a function with the given audit context.
+ * All code executed within fn (including async operations) will have access
+ * to the provided context data.
+ *
+ * @param data - The audit context data to set
+ * @param fn - The function to run with the context
+ * @returns The return value of fn
+ *
+ * @example
+ * ```typescript
+ * // In middleware or guard
+ * auditContextRun({
+ *   userId: request.user.id,
+ *   userName: request.user.email,
+ *   ip: request.ip,
+ * }, () => next());
+ * ```
+ */
+export declare function auditContextRun<T>(data: AuditContextData, fn: () => T): T;
+/**
+ * Get the current audit context data.
+ * Returns undefined if called outside of a run() context.
+ *
+ * @returns The current context data or undefined
+ *
+ * @example
+ * ```typescript
+ * const context = getAuditContext();
+ * console.log(context?.userId);
+ * ```
+ */
+export declare function getAuditContext(): AuditContextData | undefined;
+/**
+ * Update the current audit context with additional data.
+ * Merges the provided data with existing context.
+ * No-op if called outside of a run() context.
+ *
+ * @param data - Partial data to merge into the current context
+ */
+export declare function setAuditContext(data: Partial<AuditContextData>): void;
+/**
+ * AuditContext class for backward compatibility and namespacing.
+ * Provides static methods that wrap the exported functions.
+ *
+ * @example
+ * ```typescript
+ * AuditContext.run({ userId: 'user-1' }, () => {
+ *   const ctx = AuditContext.get();
+ * });
+ * ```
+ */
+export declare class AuditContext {
+    /**
+     * Run a function with the given audit context.
+     */
+    static run<T>(data: AuditContextData, fn: () => T): T;
+    /**
+     * Get the current audit context data.
+     */
+    static get(): AuditContextData | undefined;
+    /**
+     * Update the current audit context with additional data.
+     */
+    static set(data: Partial<AuditContextData>): void;
+}

package/dist/audit-context.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditContext = void 0;
+exports.auditContextRun = auditContextRun;
+exports.getAuditContext = getAuditContext;
+exports.setAuditContext = setAuditContext;
+const node_async_hooks_1 = require("node:async_hooks");
+/**
+ * Internal storage for audit context data.
+ * Uses AsyncLocalStorage to propagate context across async boundaries.
+ */
+const storage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Run a function with the given audit context.
+ * All code executed within fn (including async operations) will have access
+ * to the provided context data.
+ *
+ * @param data - The audit context data to set
+ * @param fn - The function to run with the context
+ * @returns The return value of fn
+ *
+ * @example
+ * ```typescript
+ * // In middleware or guard
+ * auditContextRun({
+ *   userId: request.user.id,
+ *   userName: request.user.email,
+ *   ip: request.ip,
+ * }, () => next());
+ * ```
+ */
+function auditContextRun(data, fn) {
+    return storage.run(data, fn);
+}
+/**
+ * Get the current audit context data.
+ * Returns undefined if called outside of a run() context.
+ *
+ * @returns The current context data or undefined
+ *
+ * @example
+ * ```typescript
+ * const context = getAuditContext();
+ * console.log(context?.userId);
+ * ```
+ */
+function getAuditContext() {
+    return storage.getStore();
+}
+/**
+ * Update the current audit context with additional data.
+ * Merges the provided data with existing context.
+ * No-op if called outside of a run() context.
+ *
+ * @param data - Partial data to merge into the current context
+ */
+function setAuditContext(data) {
+    const current = getAuditContext();
+    if (current) {
+        Object.assign(current, data);
+    }
+}
+/**
+ * AuditContext class for backward compatibility and namespacing.
+ * Provides static methods that wrap the exported functions.
+ *
+ * @example
+ * ```typescript
+ * AuditContext.run({ userId: 'user-1' }, () => {
+ *   const ctx = AuditContext.get();
+ * });
+ * ```
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: class provides namespacing for cleaner API
+class AuditContext {
+    /**
+     * Run a function with the given audit context.
+     */
+    static run(data, fn) {
+        return auditContextRun(data, fn);
+    }
+    /**
+     * Get the current audit context data.
+     */
+    static get() {
+        return getAuditContext();
+    }
+    /**
+     * Update the current audit context with additional data.
+     */
+    static set(data) {
+        setAuditContext(data);
+    }
+}
+exports.AuditContext = AuditContext;
+//# sourceMappingURL=audit-context.js.map

package/dist/audit-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-context.js","sourceRoot":"","sources":["../src/audit-context.ts"],"names":[],"mappings":";;;AA4BA,0CAEC;AAcD,0CAEC;AASD,0CAKC;AA5DD,uDAAqD;AAGrD;;;GAGG;AACH,MAAM,OAAO,GAAG,IAAI,oCAAiB,EAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,eAAe,CAAI,IAAsB,EAAE,EAAW;IACpE,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,eAAe;IAC7B,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,eAAe,CAAC,IAA+B;IAC7D,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAClC,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,6FAA6F;AAC7F,MAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,GAAG,CAAI,IAAsB,EAAE,EAAW;QAC/C,OAAO,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,GAAG;QACR,OAAO,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,GAAG,CAAC,IAA+B;QACxC,eAAe,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;CACF;AArBD,oCAqBC"}

package/dist/audit-context.middleware.d.ts

@@ -0,0 +1,76 @@
+import { type NestMiddleware } from '@nestjs/common';
+import type { NextFunction, Request, Response } from 'express';
+import type { AuditContextData } from './types';
+/**
+ * Express request with optional user property.
+ * Extend this interface if your user object has different properties.
+ */
+interface RequestWithUser extends Request {
+    user?: {
+        id?: string;
+        name?: string;
+        email?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Type for custom context extractor function.
+ * Allows customization of how audit context is extracted from requests.
+ */
+export type AuditContextExtractor = (req: RequestWithUser) => AuditContextData;
+/**
+ * Default context extractor.
+ * Extracts userId, userName, IP, and userAgent from the request.
+ */
+export declare const defaultContextExtractor: AuditContextExtractor;
+/**
+ * NestJS middleware that initializes audit context from the HTTP request.
+ * Automatically captures user information, IP address, and user agent
+ * for all audit log entries created during the request lifecycle.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * export class AppModule implements NestModule {
+ *   configure(consumer: MiddlewareConsumer) {
+ *     consumer
+ *       .apply(AuditContextMiddleware)
+ *       .forRoutes('*');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom extractor
+ * export class AppModule implements NestModule {
+ *   configure(consumer: MiddlewareConsumer) {
+ *     const middleware = new AuditContextMiddleware((req) => ({
+ *       userId: req.user?.sub,
+ *       userName: req.user?.preferred_username,
+ *       ip: req.headers['x-forwarded-for'] as string || req.ip,
+ *       userAgent: req.headers['user-agent'],
+ *       metadata: { tenantId: req.headers['x-tenant-id'] },
+ *     }));
+ *     consumer.apply(middleware.use.bind(middleware)).forRoutes('*');
+ *   }
+ * }
+ * ```
+ */
+export declare class AuditContextMiddleware implements NestMiddleware {
+    private extractor;
+    constructor(extractor?: AuditContextExtractor);
+    /**
+     * Middleware handler that wraps the request in an audit context.
+     */
+    use(req: RequestWithUser, _res: Response, next: NextFunction): void;
+}
+/**
+ * Factory function to create a middleware with a custom extractor.
+ * Useful when you need to inject dependencies into the extractor.
+ *
+ * @param extractor - Custom function to extract audit context from request
+ * @returns A new middleware instance with the custom extractor
+ */
+export declare function createAuditContextMiddleware(extractor: AuditContextExtractor): AuditContextMiddleware;
+export {};

package/dist/audit-context.middleware.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditContextMiddleware = exports.defaultContextExtractor = void 0;
+exports.createAuditContextMiddleware = createAuditContextMiddleware;
+const common_1 = require("@nestjs/common");
+const audit_context_1 = require("./audit-context");
+/**
+ * Default context extractor.
+ * Extracts userId, userName, IP, and userAgent from the request.
+ */
+const defaultContextExtractor = (req) => {
+    var _a, _b, _c, _d, _e, _f;
+    return ({
+        userId: (_a = req.user) === null || _a === void 0 ? void 0 : _a.id,
+        userName: (_c = (_b = req.user) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = req.user) === null || _d === void 0 ? void 0 : _d.email,
+        ip: (_e = req.ip) !== null && _e !== void 0 ? _e : (_f = req.socket) === null || _f === void 0 ? void 0 : _f.remoteAddress,
+        userAgent: req.headers['user-agent'],
+    });
+};
+exports.defaultContextExtractor = defaultContextExtractor;
+/**
+ * NestJS middleware that initializes audit context from the HTTP request.
+ * Automatically captures user information, IP address, and user agent
+ * for all audit log entries created during the request lifecycle.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * export class AppModule implements NestModule {
+ *   configure(consumer: MiddlewareConsumer) {
+ *     consumer
+ *       .apply(AuditContextMiddleware)
+ *       .forRoutes('*');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom extractor
+ * export class AppModule implements NestModule {
+ *   configure(consumer: MiddlewareConsumer) {
+ *     const middleware = new AuditContextMiddleware((req) => ({
+ *       userId: req.user?.sub,
+ *       userName: req.user?.preferred_username,
+ *       ip: req.headers['x-forwarded-for'] as string || req.ip,
+ *       userAgent: req.headers['user-agent'],
+ *       metadata: { tenantId: req.headers['x-tenant-id'] },
+ *     }));
+ *     consumer.apply(middleware.use.bind(middleware)).forRoutes('*');
+ *   }
+ * }
+ * ```
+ */
+let AuditContextMiddleware = class AuditContextMiddleware {
+    constructor(extractor) {
+        this.extractor = extractor !== null && extractor !== void 0 ? extractor : exports.defaultContextExtractor;
+    }
+    /**
+     * Middleware handler that wraps the request in an audit context.
+     */
+    use(req, _res, next) {
+        const contextData = this.extractor(req);
+        (0, audit_context_1.auditContextRun)(contextData, () => next());
+    }
+};
+exports.AuditContextMiddleware = AuditContextMiddleware;
+exports.AuditContextMiddleware = AuditContextMiddleware = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Function])
+], AuditContextMiddleware);
+/**
+ * Factory function to create a middleware with a custom extractor.
+ * Useful when you need to inject dependencies into the extractor.
+ *
+ * @param extractor - Custom function to extract audit context from request
+ * @returns A new middleware instance with the custom extractor
+ */
+function createAuditContextMiddleware(extractor) {
+    return new AuditContextMiddleware(extractor);
+}
+//# sourceMappingURL=audit-context.middleware.js.map

package/dist/audit-context.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-context.middleware.js","sourceRoot":"","sources":["../src/audit-context.middleware.ts"],"names":[],"mappings":";;;;;;;;;;;;AA8FA,oEAEC;AAhGD,2CAAiE;AAEjE,mDAAkD;AAuBlD;;;GAGG;AACI,MAAM,uBAAuB,GAA0B,CAAC,GAAoB,EAAoB,EAAE;;IAAC,OAAA,CAAC;QACzG,MAAM,EAAE,MAAA,GAAG,CAAC,IAAI,0CAAE,EAAE;QACpB,QAAQ,EAAE,MAAA,MAAA,GAAG,CAAC,IAAI,0CAAE,IAAI,mCAAI,MAAA,GAAG,CAAC,IAAI,0CAAE,KAAK;QAC3C,EAAE,EAAE,MAAA,GAAG,CAAC,EAAE,mCAAI,MAAA,GAAG,CAAC,MAAM,0CAAE,aAAa;QACvC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC;KACrC,CAAC,CAAA;CAAA,CAAC;AALU,QAAA,uBAAuB,2BAKjC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEI,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB;IAGjC,YAAY,SAAiC;QAC3C,IAAI,CAAC,SAAS,GAAG,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,+BAAuB,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,GAAoB,EAAE,IAAc,EAAE,IAAkB;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACxC,IAAA,+BAAe,EAAC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAdY,wDAAsB;iCAAtB,sBAAsB;IADlC,IAAA,mBAAU,GAAE;;GACA,sBAAsB,CAclC;AAED;;;;;;GAMG;AACH,SAAgB,4BAA4B,CAAC,SAAgC;IAC3E,OAAO,IAAI,sBAAsB,CAAC,SAAS,CAAC,CAAC;AAC/C,CAAC"}

package/dist/audit-log.entity.d.ts

@@ -0,0 +1,56 @@
+import type { AuditAction, AuditDiff } from './types';
+/**
+ * Entity for storing audit log entries.
+ * Tracks all changes to entities decorated with @Auditable().
+ */
+export declare class AuditLog {
+    id: string;
+    /**
+     * Name of the entity that was modified
+     */
+    entityName: string;
+    /**
+     * ID of the entity that was modified
+     */
+    entityId: string;
+    /**
+     * Type of action performed (CREATE, UPDATE, DELETE)
+     */
+    action: AuditAction;
+    /**
+     * ID of the user who made the change
+     */
+    userId: string | null;
+    /**
+     * Name/email of the user who made the change
+     */
+    userName: string | null;
+    /**
+     * Previous values of changed fields (for UPDATE/DELETE)
+     */
+    oldValues: Record<string, any> | null;
+    /**
+     * New values of changed fields (for CREATE/UPDATE)
+     */
+    newValues: Record<string, any> | null;
+    /**
+     * Computed diff of changes between old and new values
+     */
+    diff: AuditDiff[] | null;
+    /**
+     * Additional metadata captured at audit time
+     */
+    metadata: Record<string, any> | null;
+    /**
+     * IP address of the request that triggered the change
+     */
+    ip: string | null;
+    /**
+     * User agent of the request that triggered the change
+     */
+    userAgent: string | null;
+    /**
+     * Timestamp when the audit log was created
+     */
+    timestamp: Date;
+}