@nest-omni/core 4.1.3-2 → 4.1.3-3

package/audit/audit.module.d.ts

@@ -1,7 +1,17 @@
 import { DynamicModule } from '@nestjs/common';
 import { AuditConfig } from './interfaces';
+/**
+ * 审计模块
+ */
 export declare class AuditModule {
+    /**
+     * 注册审计模块
+     * @param config 审计配置
+     */
     static forRoot(config?: AuditConfig): DynamicModule;
+    /**
+     * 注册审计模块（异步）
+     */
     static forRootAsync(options: {
         imports?: any[];
         inject?: any[];

package/audit/audit.module.js

@@ -25,11 +25,19 @@ 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 {
+    /**
+     * 注册审计模块
+     * @param config 审计配置
+     */
     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) => {
@@ -43,6 +51,7 @@ let AuditModule = AuditModule_1 = class AuditModule {
                 (0, typeorm_1.getDataSourceToken)(connectionName),
             ],
         }));
+        // 创建repository别名提供者，使service能够注入正确连接的repository
         const repositoryProviders = [
             {
                 provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityAuditLogEntity),
@@ -69,6 +78,7 @@ let AuditModule = AuditModule_1 = class AuditModule {
         return {
             module: AuditModule_1,
             imports: [
+                // 审计日志存储到指定的数据库连接
                 typeorm_1.TypeOrmModule.forFeature([entities_1.EntityAuditLogEntity, entities_1.EntityTransactionEntity], auditConnectionName),
                 nestjs_cls_1.ClsModule.forRoot({
                     global: true,
@@ -108,7 +118,11 @@ let AuditModule = AuditModule_1 = class AuditModule {
             ],
         };
     }
+    /**
+     * 注册审计模块（异步）
+     */
     static forRootAsync(options) {
+        // 创建repository别名提供者，使service能够注入正确连接的repository
         const repositoryProviders = [
             {
                 provide: (0, typeorm_1.getRepositoryToken)(entities_1.EntityAuditLogEntity),
@@ -195,6 +209,7 @@ let AuditModule = AuditModule_1 = class AuditModule {
                         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';
+                        // 动态注册 TypeORM 实体
                         const typeOrmModule = typeorm_1.TypeOrmModule.forFeature([entities_1.EntityAuditLogEntity, entities_1.EntityTransactionEntity], auditConnectionName);
                         return monitoredConnections;
                     }),

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

@@ -4,17 +4,41 @@ import { AuditLogQueryDto, CompareEntitiesDto, RestoreEntityDto, PreCheckRestore
 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

@@ -27,43 +27,67 @@ 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);

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

@@ -1,5 +1,13 @@
 import { ControllerAuditOptions, MethodAuditOptions } from '../interfaces';
 export declare const CONTROLLER_AUDIT_OPTIONS: unique symbol;
 export declare const METHOD_AUDIT_OPTIONS: unique symbol;
+/**
+ * 控制器审计装饰器
+ * @param options 控制器审计选项
+ */
 export declare function EntityAuditController(options?: ControllerAuditOptions): ClassDecorator;
+/**
+ * 方法审计装饰器
+ * @param options 方法审计选项
+ */
 export declare function AuditMethod(options?: MethodAuditOptions): MethodDecorator;

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

@@ -3,13 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.METHOD_AUDIT_OPTIONS = exports.CONTROLLER_AUDIT_OPTIONS = void 0;
 exports.EntityAuditController = EntityAuditController;
 exports.AuditMethod = AuditMethod;
+// 元数据键
 exports.CONTROLLER_AUDIT_OPTIONS = Symbol('CONTROLLER_AUDIT_OPTIONS');
 exports.METHOD_AUDIT_OPTIONS = Symbol('METHOD_AUDIT_OPTIONS');
+/**
+ * 控制器审计装饰器
+ * @param options 控制器审计选项
+ */
 function EntityAuditController(options) {
     return (target) => {
         Reflect.defineMetadata(exports.CONTROLLER_AUDIT_OPTIONS, options || {}, target);
     };
 }
+/**
+ * 方法审计装饰器
+ * @param options 方法审计选项
+ */
 function AuditMethod(options) {
     return (target, propertyKey, descriptor) => {
         Reflect.defineMetadata(exports.METHOD_AUDIT_OPTIONS, options || {}, descriptor.value);

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

@@ -1,5 +1,50 @@
 import { AuditOperationOptions } from '../interfaces';
 export declare const AUDIT_OPERATION_OPTIONS: unique symbol;
+/**
+ * 方法审计装饰器
+ *
+ * @description
+ * 用于手动记录业务操作的审计日志，支持：
+ * - 自定义操作模板
+ * - 动态描述参数
+ * - 回滚操作定义
+ * - 自动事务管理
+ *
+ * @param options 审计操作选项
+ *
+ * @example
+ * ```typescript
+ * @AuditLog({
+ *   templateKey: 'user.approve',
+ *   descriptionParams: (args, result) => ({
+ *     username: args[0].username,
+ *     approver: result.approver
+ *   }),
+ *   rollbackActions: (args, result) => [{
+ *     type: RollbackActionType.UPDATE,
+ *     action: 'reject',
+ *     params: { userId: args[0].id },
+ *     order: 1
+ *   }],
+ *   autoTransaction: true
+ * })
+ * async approveUser(user: User): Promise<ApprovalResult> {
+ *   // 业务逻辑
+ * }
+ * ```
+ */
 export declare function AuditLog(options: AuditOperationOptions): MethodDecorator;
+/**
+ * 获取方法的审计配置
+ * @param target 目标类或实例
+ * @param propertyKey 方法名
+ * @returns 审计操作选项
+ */
 export declare function getAuditOperationConfig(target: any, propertyKey: string | symbol): AuditOperationOptions | undefined;
+/**
+ * 检查方法是否配置了审计
+ * @param target 目标类或实例
+ * @param propertyKey 方法名
+ * @returns 是否配置了审计
+ */
 export declare function hasAuditOperation(target: any, propertyKey: string | symbol): boolean;

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

@@ -4,20 +4,69 @@ exports.AUDIT_OPERATION_OPTIONS = void 0;
 exports.AuditLog = AuditLog;
 exports.getAuditOperationConfig = getAuditOperationConfig;
 exports.hasAuditOperation = hasAuditOperation;
+// 元数据键
 exports.AUDIT_OPERATION_OPTIONS = Symbol('AUDIT_OPERATION_OPTIONS');
+/**
+ * 方法审计装饰器
+ *
+ * @description
+ * 用于手动记录业务操作的审计日志，支持：
+ * - 自定义操作模板
+ * - 动态描述参数
+ * - 回滚操作定义
+ * - 自动事务管理
+ *
+ * @param options 审计操作选项
+ *
+ * @example
+ * ```typescript
+ * @AuditLog({
+ *   templateKey: 'user.approve',
+ *   descriptionParams: (args, result) => ({
+ *     username: args[0].username,
+ *     approver: result.approver
+ *   }),
+ *   rollbackActions: (args, result) => [{
+ *     type: RollbackActionType.UPDATE,
+ *     action: 'reject',
+ *     params: { userId: args[0].id },
+ *     order: 1
+ *   }],
+ *   autoTransaction: true
+ * })
+ * async approveUser(user: User): Promise<ApprovalResult> {
+ *   // 业务逻辑
+ * }
+ * ```
+ */
 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);
+        // 返回原始描述符，实际的拦截逻辑由 AuditInterceptor 处理
         return descriptor;
     };
 }
+/**
+ * 获取方法的审计配置
+ * @param target 目标类或实例
+ * @param propertyKey 方法名
+ * @returns 审计操作选项
+ */
 function getAuditOperationConfig(target, propertyKey) {
     return Reflect.getMetadata(exports.AUDIT_OPERATION_OPTIONS, target, propertyKey);
 }
+/**
+ * 检查方法是否配置了审计
+ * @param target 目标类或实例
+ * @param propertyKey 方法名
+ * @returns 是否配置了审计
+ */
 function hasAuditOperation(target, propertyKey) {
     return Reflect.hasMetadata(exports.AUDIT_OPERATION_OPTIONS, target, propertyKey);
 }

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

@@ -1,5 +1,13 @@
 import { EntityAuditConfig, FieldDisplayOptions } from '../interfaces';
 export declare const ENTITY_AUDIT_OPTIONS: unique symbol;
 export declare const FIELD_AUDIT_OPTIONS: unique symbol;
+/**
+ * 实体审计装饰器
+ * @param options 审计配置选项
+ */
 export declare function EntityAudit(options?: EntityAuditConfig): ClassDecorator;
+/**
+ * 字段审计装饰器
+ * @param options 字段显示选项
+ */
 export declare function AuditField(options?: FieldDisplayOptions): PropertyDecorator;

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

@@ -3,13 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIELD_AUDIT_OPTIONS = exports.ENTITY_AUDIT_OPTIONS = void 0;
 exports.EntityAudit = EntityAudit;
 exports.AuditField = AuditField;
+// 元数据键
 exports.ENTITY_AUDIT_OPTIONS = Symbol('ENTITY_AUDIT_OPTIONS');
 exports.FIELD_AUDIT_OPTIONS = Symbol('FIELD_AUDIT_OPTIONS');
+/**
+ * 实体审计装饰器
+ * @param options 审计配置选项
+ */
 function EntityAudit(options) {
     return (target) => {
         Reflect.defineMetadata(exports.ENTITY_AUDIT_OPTIONS, options || {}, target);
     };
 }
+/**
+ * 字段审计装饰器
+ * @param options 字段显示选项
+ */
 function AuditField(options) {
     return (target, propertyKey) => {
         const existingOptions = Reflect.getMetadata(exports.FIELD_AUDIT_OPTIONS, target.constructor) || {};

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

@@ -1,4 +1,7 @@
 import { AuditOperation } from '../enums';
+/**
+ * 审计日志查询DTO
+ */
 export declare class AuditLogQueryDto {
     page?: number;
     limit?: number;

package/audit/dto/audit-log-query.dto.js

@@ -14,6 +14,9 @@ const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
 const enums_1 = require("../enums");
+/**
+ * 审计日志查询DTO
+ */
 class AuditLogQueryDto {
     constructor() {
         this.page = 1;

package/audit/dto/begin-transaction.dto.d.ts

@@ -1,3 +1,6 @@
+/**
+ * 开始事务DTO
+ */
 export declare class BeginTransactionDto {
     description: string;
 }

package/audit/dto/begin-transaction.dto.js

@@ -12,6 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BeginTransactionDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
+/**
+ * 开始事务DTO
+ */
 class BeginTransactionDto {
 }
 exports.BeginTransactionDto = BeginTransactionDto;

package/audit/dto/compare-entities.dto.d.ts

@@ -1,3 +1,6 @@
+/**
+ * 比较实体DTO
+ */
 export declare class CompareEntitiesDto {
     entityType: string;
     entityId: string;

package/audit/dto/compare-entities.dto.js

@@ -13,6 +13,9 @@ exports.CompareEntitiesDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
+/**
+ * 比较实体DTO
+ */
 class CompareEntitiesDto {
 }
 exports.CompareEntitiesDto = CompareEntitiesDto;

package/audit/dto/pre-check-restore.dto.d.ts

@@ -1,3 +1,6 @@
+/**
+ * 预检查恢复DTO
+ */
 export declare class PreCheckRestoreDto {
     entityType: string;
     entityId: string;

package/audit/dto/pre-check-restore.dto.js

@@ -12,6 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PreCheckRestoreDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
+/**
+ * 预检查恢复DTO
+ */
 class PreCheckRestoreDto {
 }
 exports.PreCheckRestoreDto = PreCheckRestoreDto;

package/audit/dto/restore-entity.dto.d.ts

@@ -1,5 +1,8 @@
 import { RecoveryStrategy } from '../enums';
 import { RestoreOptions } from '../interfaces';
+/**
+ * 恢复实体DTO
+ */
 export declare class RestoreEntityDto {
     entityType: string;
     entityId: string;

package/audit/dto/restore-entity.dto.js

@@ -13,6 +13,9 @@ exports.RestoreEntityDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const enums_1 = require("../enums");
+/**
+ * 恢复实体DTO
+ */
 class RestoreEntityDto {
     constructor() {
         this.strategy = enums_1.RecoveryStrategy.ENTITY_ONLY;

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

@@ -1,5 +1,8 @@
 import { AbstractUuidPrimaryEntity } from '../../common/abstract.entity';
 import { AuditOperation } from '../enums';
+/**
+ * 实体审计日志
+ */
 export declare class EntityAuditLogEntity extends AbstractUuidPrimaryEntity {
     entityType: string;
     entityId: string;

package/audit/entities/entity-audit-log.entity.js

@@ -13,6 +13,9 @@ exports.EntityAuditLogEntity = void 0;
 const typeorm_1 = require("typeorm");
 const abstract_entity_1 = require("../../common/abstract.entity");
 const enums_1 = require("../enums");
+/**
+ * 实体审计日志
+ */
 let EntityAuditLogEntity = class EntityAuditLogEntity extends abstract_entity_1.AbstractUuidPrimaryEntity {
 };
 exports.EntityAuditLogEntity = EntityAuditLogEntity;

package/audit/entities/entity-transaction.entity.d.ts

@@ -1,5 +1,8 @@
 import { AbstractUuidPrimaryEntity } from '../../common/abstract.entity';
 import { AuditOperation, TransactionStatus } from '../enums';
+/**
+ * 实体事务
+ */
 export declare class EntityTransactionEntity extends AbstractUuidPrimaryEntity {
     description: string;
     status: TransactionStatus;

package/audit/entities/entity-transaction.entity.js

@@ -13,6 +13,9 @@ exports.EntityTransactionEntity = void 0;
 const typeorm_1 = require("typeorm");
 const abstract_entity_1 = require("../../common/abstract.entity");
 const enums_1 = require("../enums");
+/**
+ * 实体事务
+ */
 let EntityTransactionEntity = class EntityTransactionEntity extends abstract_entity_1.AbstractUuidPrimaryEntity {
 };
 exports.EntityTransactionEntity = EntityTransactionEntity;

package/audit/entities/manual-operation-log.entity.d.ts

@@ -1,6 +1,10 @@
 import { AbstractUuidPrimaryEntity } from '../../common/abstract.entity';
 import { EntityTransactionEntity } from './entity-transaction.entity';
 import { RollbackAction } from '../interfaces';
+/**
+ * 手动操作记录表
+ * 用于记录跨实体的复杂业务操作
+ */
 export declare class ManualOperationLogEntity extends AbstractUuidPrimaryEntity {
     transactionId: string;
     operationTemplateKey: string;

package/audit/entities/manual-operation-log.entity.js

@@ -13,6 +13,10 @@ exports.ManualOperationLogEntity = void 0;
 const typeorm_1 = require("typeorm");
 const abstract_entity_1 = require("../../common/abstract.entity");
 const entity_transaction_entity_1 = require("./entity-transaction.entity");
+/**
+ * 手动操作记录表
+ * 用于记录跨实体的复杂业务操作
+ */
 let ManualOperationLogEntity = class ManualOperationLogEntity extends abstract_entity_1.AbstractUuidPrimaryEntity {
 };
 exports.ManualOperationLogEntity = ManualOperationLogEntity;

package/audit/entities/operation-template.entity.d.ts

@@ -1,5 +1,9 @@
 import { AbstractUuidPrimaryEntity } from '../../common/abstract.entity';
 import { AuditOperation } from '../enums';
+/**
+ * 操作模板配置表
+ * 用于存储多语言操作描述模板
+ */
 export declare class OperationTemplateEntity extends AbstractUuidPrimaryEntity {
     key: string;
     entityName: string;

package/audit/entities/operation-template.entity.js

@@ -13,6 +13,10 @@ exports.OperationTemplateEntity = void 0;
 const typeorm_1 = require("typeorm");
 const abstract_entity_1 = require("../../common/abstract.entity");
 const enums_1 = require("../enums");
+/**
+ * 操作模板配置表
+ * 用于存储多语言操作描述模板
+ */
 let OperationTemplateEntity = class OperationTemplateEntity extends abstract_entity_1.AbstractUuidPrimaryEntity {
 };
 exports.OperationTemplateEntity = OperationTemplateEntity;

package/audit/enums/audit.enums.d.ts

@@ -1,24 +1,39 @@
+/**
+ * 审计操作类型
+ */
 export declare enum AuditOperation {
     CREATE = "CREATE",
     UPDATE = "UPDATE",
     DELETE = "DELETE",
     RESTORE = "RESTORE"
 }
+/**
+ * 事务状态
+ */
 export declare enum TransactionStatus {
     PENDING = "PENDING",
     COMMITTED = "COMMITTED",
     ROLLED_BACK = "ROLLED_BACK"
 }
+/**
+ * 恢复策略
+ */
 export declare enum RecoveryStrategy {
     ENTITY_ONLY = "ENTITY_ONLY",
     TRANSACTION_RESTORE = "TRANSACTION_RESTORE",
     DEPENDENCY_GRAPH = "DEPENDENCY_GRAPH"
 }
+/**
+ * 记录策略
+ */
 export declare enum RecordStrategy {
-    FULL = "FULL",
-    DIFF_ONLY = "DIFF_ONLY",
+    FULL = "FULL",// 记录完整变更
+    DIFF_ONLY = "DIFF_ONLY",// 仅记录差异
     DISABLED = "DISABLED"
 }
+/**
+ * 脱敏策略
+ */
 export declare enum MaskingStrategy {
     NONE = "NONE",
     HASH = "HASH",

package/audit/enums/audit.enums.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaskingStrategy = exports.RecordStrategy = exports.RecoveryStrategy = exports.TransactionStatus = exports.AuditOperation = void 0;
+/**
+ * 审计操作类型
+ */
 var AuditOperation;
 (function (AuditOperation) {
     AuditOperation["CREATE"] = "CREATE";
@@ -8,24 +11,36 @@ var AuditOperation;
     AuditOperation["DELETE"] = "DELETE";
     AuditOperation["RESTORE"] = "RESTORE";
 })(AuditOperation || (exports.AuditOperation = AuditOperation = {}));
+/**
+ * 事务状态
+ */
 var TransactionStatus;
 (function (TransactionStatus) {
     TransactionStatus["PENDING"] = "PENDING";
     TransactionStatus["COMMITTED"] = "COMMITTED";
     TransactionStatus["ROLLED_BACK"] = "ROLLED_BACK";
 })(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+/**
+ * 恢复策略
+ */
 var RecoveryStrategy;
 (function (RecoveryStrategy) {
     RecoveryStrategy["ENTITY_ONLY"] = "ENTITY_ONLY";
     RecoveryStrategy["TRANSACTION_RESTORE"] = "TRANSACTION_RESTORE";
     RecoveryStrategy["DEPENDENCY_GRAPH"] = "DEPENDENCY_GRAPH";
 })(RecoveryStrategy || (exports.RecoveryStrategy = RecoveryStrategy = {}));
+/**
+ * 记录策略
+ */
 var RecordStrategy;
 (function (RecordStrategy) {
     RecordStrategy["FULL"] = "FULL";
     RecordStrategy["DIFF_ONLY"] = "DIFF_ONLY";
     RecordStrategy["DISABLED"] = "DISABLED";
 })(RecordStrategy || (exports.RecordStrategy = RecordStrategy = {}));
+/**
+ * 脱敏策略
+ */
 var MaskingStrategy;
 (function (MaskingStrategy) {
     MaskingStrategy["NONE"] = "NONE";