@nest-omni/core 3.1.2-8 → 3.1.2-9

package/audit/audit.module.d.ts

@@ -0,0 +1,10 @@
+import { DynamicModule } from '@nestjs/common';
+import { AuditConfig } from './interfaces';
+export declare class AuditModule {
+    static forRoot(config?: AuditConfig): DynamicModule;
+    static forRootAsync(options: {
+        imports?: any[];
+        inject?: any[];
+        useFactory: (...args: any[]) => Promise<AuditConfig> | AuditConfig;
+    }): DynamicModule;
+}

package/audit/audit.module.js

@@ -0,0 +1,254 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var AuditModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const nestjs_cls_1 = require("nestjs-cls");
+const entities_1 = require("./entities");
+const services_1 = require("./services");
+const subscribers_1 = require("./subscribers");
+const interceptors_1 = require("./interceptors");
+const controllers_1 = require("./controllers");
+let AuditModule = AuditModule_1 = class AuditModule {
+    static forRoot(config) {
+        var _a, _b;
+        const auditConnectionName = ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.audit) || 'default';
+        const monitoredConnections = ((_b = config === null || config === void 0 ? void 0 : config.connections) === null || _b === void 0 ? void 0 : _b.monitored) || ['default'];
+        const subscriberProviders = monitoredConnections.map((connectionName) => ({
+            provide: `AUDIT_SUBSCRIBER_${connectionName}`,
+            useFactory: (auditService, contextService, auditStrategy, dataSource) => {
+                const subscriber = new subscribers_1.EntityAuditSubscriber(auditService, contextService, auditStrategy, dataSource);
+                return subscriber;
+            },
+            inject: [
+                services_1.EntityAuditService,
+                services_1.AuditContextService,
+                services_1.DefaultAuditStrategy,
+                (0, typeorm_1.getDataSourceToken)(connectionName),
+            ],
+        }));
+        const repositoryProviders = [
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityAuditLogEntity),
+                useFactory: (dataSource) => {
+                    return dataSource.getRepository(entities_1.EntityAuditLogEntity);
+                },
+                inject: [(0, typeorm_1.getDataSourceToken)(auditConnectionName)],
+            },
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityTransactionEntity),
+                useFactory: (dataSource) => {
+                    return dataSource.getRepository(entities_1.EntityTransactionEntity);
+                },
+                inject: [(0, typeorm_1.getDataSourceToken)(auditConnectionName)],
+            },
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.OperationTemplateEntity),
+                useFactory: (dataSource) => {
+                    return dataSource.getRepository(entities_1.OperationTemplateEntity);
+                },
+                inject: [(0, typeorm_1.getDataSourceToken)(auditConnectionName)],
+            },
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.ManualOperationLogEntity),
+                useFactory: (dataSource) => {
+                    return dataSource.getRepository(entities_1.ManualOperationLogEntity);
+                },
+                inject: [(0, typeorm_1.getDataSourceToken)(auditConnectionName)],
+            },
+            {
+                provide: 'AUDIT_ENTITY_MANAGER',
+                useFactory: (dataSource) => {
+                    return dataSource.manager;
+                },
+                inject: [(0, typeorm_1.getDataSourceToken)(auditConnectionName)],
+            },
+        ];
+        return {
+            module: AuditModule_1,
+            imports: [
+                typeorm_1.TypeOrmModule.forFeature([
+                    entities_1.EntityAuditLogEntity,
+                    entities_1.EntityTransactionEntity,
+                    entities_1.OperationTemplateEntity,
+                    entities_1.ManualOperationLogEntity,
+                ], auditConnectionName),
+                nestjs_cls_1.ClsModule.forRoot({
+                    global: true,
+                    middleware: { mount: true },
+                }),
+            ],
+            controllers: [controllers_1.AuditController],
+            providers: [
+                {
+                    provide: 'AUDIT_CONFIG',
+                    useValue: config || {},
+                },
+                {
+                    provide: 'AUDIT_STRATEGY',
+                    useClass: services_1.DefaultAuditStrategy,
+                },
+                {
+                    provide: 'AUDIT_CONNECTION_NAME',
+                    useValue: auditConnectionName,
+                },
+                services_1.AuditContextService,
+                services_1.DefaultAuditStrategy,
+                services_1.MultiDatabaseService,
+                ...repositoryProviders,
+                services_1.EntityAuditService,
+                services_1.TransactionAuditService,
+                services_1.OperationDescriptionService,
+                interceptors_1.AuditInterceptor,
+                ...subscriberProviders,
+            ],
+            exports: [
+                services_1.AuditContextService,
+                services_1.DefaultAuditStrategy,
+                services_1.MultiDatabaseService,
+                services_1.EntityAuditService,
+                services_1.TransactionAuditService,
+                services_1.OperationDescriptionService,
+                interceptors_1.AuditInterceptor,
+            ],
+        };
+    }
+    static forRootAsync(options) {
+        const repositoryProviders = [
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityAuditLogEntity),
+                useFactory: (dataSource, ...args) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const config = yield options.useFactory(...args);
+                    const auditConnectionName = ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.audit) || 'default';
+                    return dataSource.getRepository(entities_1.EntityAuditLogEntity);
+                }),
+                inject: [
+                    {
+                        token: (0, typeorm_1.getDataSourceToken)(),
+                        optional: false,
+                    },
+                    ...(options.inject || []),
+                ],
+            },
+            {
+                provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityTransactionEntity),
+                useFactory: (dataSource, ...args) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const config = yield options.useFactory(...args);
+                    const auditConnectionName = ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.audit) || 'default';
+                    return dataSource.getRepository(entities_1.EntityTransactionEntity);
+                }),
+                inject: [
+                    {
+                        token: (0, typeorm_1.getDataSourceToken)(),
+                        optional: false,
+                    },
+                    ...(options.inject || []),
+                ],
+            },
+            {
+                provide: 'AUDIT_ENTITY_MANAGER',
+                useFactory: (dataSource, ...args) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const config = yield options.useFactory(...args);
+                    const auditConnectionName = ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.audit) || 'default';
+                    return dataSource.manager;
+                }),
+                inject: [
+                    {
+                        token: (0, typeorm_1.getDataSourceToken)(),
+                        optional: false,
+                    },
+                    ...(options.inject || []),
+                ],
+            },
+        ];
+        return {
+            module: AuditModule_1,
+            imports: [
+                nestjs_cls_1.ClsModule.forRoot({
+                    global: true,
+                    middleware: { mount: true },
+                }),
+                ...(options.imports || []),
+            ],
+            controllers: [controllers_1.AuditController],
+            providers: [
+                {
+                    provide: 'AUDIT_CONFIG',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: 'AUDIT_STRATEGY',
+                    useClass: services_1.DefaultAuditStrategy,
+                },
+                {
+                    provide: 'AUDIT_CONNECTION_NAME',
+                    useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const config = yield options.useFactory(...args);
+                        return ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.audit) || 'default';
+                    }),
+                    inject: options.inject || [],
+                },
+                {
+                    provide: 'AUDIT_SUBSCRIBERS',
+                    useFactory: (auditService, contextService, auditStrategy, ...args) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        const config = yield options.useFactory(...args);
+                        const monitoredConnections = ((_a = config === null || config === void 0 ? void 0 : config.connections) === null || _a === void 0 ? void 0 : _a.monitored) || ['default'];
+                        const auditConnectionName = ((_b = config === null || config === void 0 ? void 0 : config.connections) === null || _b === void 0 ? void 0 : _b.audit) || 'default';
+                        const typeOrmModule = typeorm_1.TypeOrmModule.forFeature([entities_1.EntityAuditLogEntity, entities_1.EntityTransactionEntity], auditConnectionName);
+                        return monitoredConnections;
+                    }),
+                    inject: [
+                        services_1.EntityAuditService,
+                        services_1.AuditContextService,
+                        services_1.DefaultAuditStrategy,
+                        ...(options.inject || []),
+                    ],
+                },
+                services_1.AuditContextService,
+                services_1.DefaultAuditStrategy,
+                services_1.MultiDatabaseService,
+                ...repositoryProviders,
+                services_1.EntityAuditService,
+                services_1.TransactionAuditService,
+                services_1.OperationDescriptionService,
+                interceptors_1.AuditInterceptor,
+            ],
+            exports: [
+                services_1.AuditContextService,
+                services_1.DefaultAuditStrategy,
+                services_1.MultiDatabaseService,
+                services_1.EntityAuditService,
+                services_1.TransactionAuditService,
+                services_1.OperationDescriptionService,
+                interceptors_1.AuditInterceptor,
+            ],
+        };
+    }
+};
+exports.AuditModule = AuditModule;
+exports.AuditModule = AuditModule = AuditModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], AuditModule);

package/audit/controllers/audit.controller.d.ts

@@ -0,0 +1,20 @@
+import { EntityAuditService } from '../services/entity-audit.service';
+import { TransactionAuditService } from '../services/transaction-audit.service';
+import { AuditLogQueryDto, CompareEntitiesDto, RestoreEntityDto, PreCheckRestoreDto, BeginTransactionDto } from '../dto';
+import { EntityAuditLogEntity } from '../entities';
+import { EntityDifference, PreCheckResult, RestoreResult } from '../interfaces';
+import { PageDto } from '../../common/dto';
+export declare class AuditController {
+    private readonly entityAuditService;
+    private readonly transactionAuditService;
+    constructor(entityAuditService: EntityAuditService, transactionAuditService: TransactionAuditService);
+    getAuditLogs(query: AuditLogQueryDto): Promise<PageDto<EntityAuditLogEntity>>;
+    compareEntities(query: CompareEntitiesDto): Promise<EntityDifference>;
+    preCheckRestore(preCheckDto: PreCheckRestoreDto): Promise<PreCheckResult>;
+    restoreEntity(restoreDto: RestoreEntityDto): Promise<RestoreResult>;
+    beginTransaction(beginTransactionDto: BeginTransactionDto): Promise<{
+        transactionId: string;
+    }>;
+    commitTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
+}

package/audit/controllers/audit.controller.js

@@ -0,0 +1,142 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const entity_audit_service_1 = require("../services/entity-audit.service");
+const transaction_audit_service_1 = require("../services/transaction-audit.service");
+const dto_1 = require("../dto");
+let AuditController = class AuditController {
+    constructor(entityAuditService, transactionAuditService) {
+        this.entityAuditService = entityAuditService;
+        this.transactionAuditService = transactionAuditService;
+    }
+    getAuditLogs(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.entityAuditService.getAuditLogs(query);
+        });
+    }
+    compareEntities(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return this.entityAuditService.compareEntities(query.entityType, query.entityId, (_a = query.fromVersion) === null || _a === void 0 ? void 0 : _a.toString(), (_b = query.toVersion) === null || _b === void 0 ? void 0 : _b.toString());
+        });
+    }
+    preCheckRestore(preCheckDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.entityAuditService.preCheckRestore(preCheckDto.entityType, preCheckDto.entityId, preCheckDto.auditLogId);
+        });
+    }
+    restoreEntity(restoreDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.entityAuditService.restoreEntity(restoreDto.entityType, restoreDto.entityId, restoreDto.auditLogId, restoreDto.options);
+        });
+    }
+    beginTransaction(beginTransactionDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactionId = yield this.transactionAuditService.beginTransaction(beginTransactionDto.description);
+            return { transactionId };
+        });
+    }
+    commitTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transactionAuditService.commitTransaction(transactionId);
+        });
+    }
+    rollbackTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transactionAuditService.rollbackTransaction(transactionId);
+        });
+    }
+};
+exports.AuditController = AuditController;
+__decorate([
+    (0, common_1.Get)('logs'),
+    (0, swagger_1.ApiOperation)({ summary: '查询实体审计日志' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功返回审计日志列表' }),
+    __param(0, (0, common_1.Query)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [dto_1.AuditLogQueryDto]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "getAuditLogs", null);
+__decorate([
+    (0, common_1.Get)('compare'),
+    (0, swagger_1.ApiOperation)({ summary: '比较实体版本' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功返回比较结果' }),
+    __param(0, (0, common_1.Query)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [dto_1.CompareEntitiesDto]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "compareEntities", null);
+__decorate([
+    (0, common_1.Post)('restore/precheck'),
+    (0, swagger_1.ApiOperation)({ summary: '预检查恢复操作' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功返回预检查结果' }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [dto_1.PreCheckRestoreDto]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "preCheckRestore", null);
+__decorate([
+    (0, common_1.Post)('restore'),
+    (0, swagger_1.ApiOperation)({ summary: '恢复实体到指定版本' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功恢复实体' }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [dto_1.RestoreEntityDto]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "restoreEntity", null);
+__decorate([
+    (0, common_1.Post)('transactions'),
+    (0, swagger_1.ApiOperation)({ summary: '开始审计事务' }),
+    (0, swagger_1.ApiResponse)({ status: 201, description: '成功创建事务' }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [dto_1.BeginTransactionDto]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "beginTransaction", null);
+__decorate([
+    (0, common_1.Post)('transactions/:transactionId/commit'),
+    (0, swagger_1.ApiOperation)({ summary: '提交审计事务' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功提交事务' }),
+    __param(0, (0, common_1.Param)('transactionId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "commitTransaction", null);
+__decorate([
+    (0, common_1.Post)('transactions/:transactionId/rollback'),
+    (0, swagger_1.ApiOperation)({ summary: '回滚审计事务' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: '成功回滚事务' }),
+    __param(0, (0, common_1.Param)('transactionId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AuditController.prototype, "rollbackTransaction", null);
+exports.AuditController = AuditController = __decorate([
+    (0, common_1.Controller)('audit'),
+    (0, swagger_1.ApiTags)('audit'),
+    __metadata("design:paramtypes", [entity_audit_service_1.EntityAuditService,
+        transaction_audit_service_1.TransactionAuditService])
+], AuditController);

package/audit/controllers/index.d.ts

@@ -0,0 +1 @@
+export * from './audit.controller';

package/audit/controllers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.controller"), exports);

package/audit/decorators/audit-controller.decorator.d.ts

@@ -0,0 +1,5 @@
+import { ControllerAuditOptions, MethodAuditOptions } from '../interfaces';
+export declare const CONTROLLER_AUDIT_OPTIONS: unique symbol;
+export declare const METHOD_AUDIT_OPTIONS: unique symbol;
+export declare function AuditController(options?: ControllerAuditOptions): ClassDecorator;
+export declare function AuditMethod(options?: MethodAuditOptions): MethodDecorator;

package/audit/decorators/audit-controller.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHOD_AUDIT_OPTIONS = exports.CONTROLLER_AUDIT_OPTIONS = void 0;
+exports.AuditController = AuditController;
+exports.AuditMethod = AuditMethod;
+exports.CONTROLLER_AUDIT_OPTIONS = Symbol('CONTROLLER_AUDIT_OPTIONS');
+exports.METHOD_AUDIT_OPTIONS = Symbol('METHOD_AUDIT_OPTIONS');
+function AuditController(options) {
+    return (target) => {
+        Reflect.defineMetadata(exports.CONTROLLER_AUDIT_OPTIONS, options || {}, target);
+    };
+}
+function AuditMethod(options) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(exports.METHOD_AUDIT_OPTIONS, options || {}, descriptor.value);
+    };
+}

package/audit/decorators/audit-operation.decorator.d.ts

@@ -0,0 +1,7 @@
+import { AuditOperationOptions } from '../interfaces';
+export declare const AUDIT_OPERATION_OPTIONS: unique symbol;
+export declare function AuditLog(options: AuditOperationOptions): MethodDecorator;
+export declare function getAuditOperationConfig(target: any, propertyKey: string | symbol): AuditOperationOptions | undefined;
+export declare function hasAuditOperation(target: any, propertyKey: string | symbol): boolean;
+export declare const LogOperation: typeof AuditLog;
+export declare const AuditOperation: typeof AuditLog;

package/audit/decorators/audit-operation.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditOperation = exports.LogOperation = exports.AUDIT_OPERATION_OPTIONS = void 0;
+exports.AuditLog = AuditLog;
+exports.getAuditOperationConfig = getAuditOperationConfig;
+exports.hasAuditOperation = hasAuditOperation;
+exports.AUDIT_OPERATION_OPTIONS = Symbol('AUDIT_OPERATION_OPTIONS');
+function AuditLog(options) {
+    return (target, propertyKey, descriptor) => {
+        if (!options.templateKey) {
+            throw new Error(`@AuditLog requires templateKey for method ${String(propertyKey)}`);
+        }
+        const methodMetadata = Object.assign(Object.assign({}, options), { methodName: String(propertyKey) });
+        Reflect.defineMetadata(exports.AUDIT_OPERATION_OPTIONS, methodMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+function getAuditOperationConfig(target, propertyKey) {
+    return Reflect.getMetadata(exports.AUDIT_OPERATION_OPTIONS, target, propertyKey);
+}
+function hasAuditOperation(target, propertyKey) {
+    return Reflect.hasMetadata(exports.AUDIT_OPERATION_OPTIONS, target, propertyKey);
+}
+exports.LogOperation = AuditLog;
+exports.AuditOperation = AuditLog;

package/audit/decorators/entity-audit.decorator.d.ts

@@ -0,0 +1,10 @@
+import { EntityAuditConfig, FieldDisplayOptions } from '../interfaces';
+export declare const ENTITY_AUDIT_OPTIONS: unique symbol;
+export declare const FIELD_AUDIT_OPTIONS: unique symbol;
+export declare function AuditEntity(options?: EntityAuditConfig): ClassDecorator;
+export declare function AuditField(options?: FieldDisplayOptions): PropertyDecorator;
+export declare function getEntityAuditConfig(target: any): EntityAuditConfig;
+export declare function getFieldAuditConfig(target: any): Record<string, FieldDisplayOptions>;
+export declare function getFieldLabel(target: any, fieldName: string, language?: string): string;
+export declare function getFieldValueLabel(target: any, fieldName: string, value: any, language?: string): string;
+export declare const EntityAudit: typeof AuditEntity;

package/audit/decorators/entity-audit.decorator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityAudit = exports.FIELD_AUDIT_OPTIONS = exports.ENTITY_AUDIT_OPTIONS = void 0;
+exports.AuditEntity = AuditEntity;
+exports.AuditField = AuditField;
+exports.getEntityAuditConfig = getEntityAuditConfig;
+exports.getFieldAuditConfig = getFieldAuditConfig;
+exports.getFieldLabel = getFieldLabel;
+exports.getFieldValueLabel = getFieldValueLabel;
+exports.ENTITY_AUDIT_OPTIONS = Symbol('ENTITY_AUDIT_OPTIONS');
+exports.FIELD_AUDIT_OPTIONS = Symbol('FIELD_AUDIT_OPTIONS');
+function AuditEntity(options) {
+    return (target) => {
+        const mergedOptions = Object.assign(Object.assign({}, options), { maskFields: [
+                ...((options === null || options === void 0 ? void 0 : options.maskFields) || []),
+                ...((options === null || options === void 0 ? void 0 : options.sensitiveFields) || []),
+            ] });
+        if (mergedOptions.maskFields && mergedOptions.maskFields.length > 0) {
+            mergedOptions.maskFields = [...new Set(mergedOptions.maskFields)];
+        }
+        Reflect.defineMetadata(exports.ENTITY_AUDIT_OPTIONS, mergedOptions, target);
+        if (mergedOptions.templateKey) {
+            Reflect.defineMetadata('entity-log:enabled', true, target);
+            Reflect.defineMetadata('entity-log:options', {
+                templateKey: mergedOptions.templateKey,
+                excludeFields: mergedOptions.excludeFields,
+                sensitiveFields: mergedOptions.maskFields,
+            }, target);
+        }
+    };
+}
+function AuditField(options) {
+    return (target, propertyKey) => {
+        const existingOptions = Reflect.getMetadata(exports.FIELD_AUDIT_OPTIONS, target.constructor) || {};
+        existingOptions[propertyKey] = options || {};
+        Reflect.defineMetadata(exports.FIELD_AUDIT_OPTIONS, existingOptions, target.constructor);
+    };
+}
+function getEntityAuditConfig(target) {
+    return Reflect.getMetadata(exports.ENTITY_AUDIT_OPTIONS, target) || {};
+}
+function getFieldAuditConfig(target) {
+    return Reflect.getMetadata(exports.FIELD_AUDIT_OPTIONS, target) || {};
+}
+function getFieldLabel(target, fieldName, language = 'zh') {
+    var _a;
+    const fieldConfig = getFieldAuditConfig(target);
+    const label = (_a = fieldConfig[fieldName]) === null || _a === void 0 ? void 0 : _a.label;
+    if (!label) {
+        return fieldName;
+    }
+    if (typeof label === 'string') {
+        return label;
+    }
+    return label[language] || label['zh'] || fieldName;
+}
+function getFieldValueLabel(target, fieldName, value, language = 'zh') {
+    var _a;
+    const fieldConfig = getFieldAuditConfig(target);
+    const valueLabels = (_a = fieldConfig[fieldName]) === null || _a === void 0 ? void 0 : _a.valueLabels;
+    if (!valueLabels || !valueLabels[value]) {
+        return value;
+    }
+    const labelMap = valueLabels[value];
+    if (typeof labelMap === 'string') {
+        return labelMap;
+    }
+    return labelMap[language] || labelMap['zh'] || value;
+}
+exports.EntityAudit = AuditEntity;

package/audit/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-audit.decorator';
+export * from './audit-controller.decorator';
+export * from './audit-operation.decorator';

package/audit/decorators/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entity-audit.decorator"), exports);
+__exportStar(require("./audit-controller.decorator"), exports);
+__exportStar(require("./audit-operation.decorator"), exports);

package/audit/dto/audit-log-query.dto.d.ts

@@ -0,0 +1,14 @@
+import { AuditOperation } from '../enums';
+export declare class AuditLogQueryDto {
+    page?: number;
+    limit?: number;
+    entityType?: string;
+    entityId?: string;
+    operation?: AuditOperation;
+    userId?: string;
+    startDate?: string;
+    endDate?: string;
+    search?: string;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+}