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

package/common/boilerplate.polyfill.d.ts

@@ -16,10 +16,6 @@ declare global {
     }
 }
 declare module 'typeorm' {
-    interface Repository<Entity extends ObjectLiteral> {
-        saveWithPk(this: Repository<Entity>, entity: Entity | Entity[]): Promise<Entity | Entity[]>;
-        getPrimaryKeyFields(this: Repository<Entity>): string[];
-    }
     interface SelectQueryBuilder<Entity> {
         searchByString(q: string, columnNames: string[], options?: {
             formStart: boolean;

package/common/boilerplate.polyfill.js

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("source-map-support/register");
 const lodash_1 = require("lodash");
 const typeorm_1 = require("typeorm");
-const typeorm_2 = require("typeorm");
 const page_dto_1 = require("./dto/page.dto");
 const page_meta_dto_1 = require("./dto/page-meta.dto");
 const providers_1 = require("../providers");
@@ -44,11 +43,11 @@ Array.prototype.getByLanguage = function (languageCode) {
 Array.prototype.toPageDto = function (pageMetaDto, options) {
     return new page_dto_1.PageDto(this.toDtos(options), pageMetaDto);
 };
-typeorm_2.SelectQueryBuilder.prototype.searchByString = function (q, columnNames, options) {
+typeorm_1.SelectQueryBuilder.prototype.searchByString = function (q, columnNames, options) {
     if (!q) {
         return this;
     }
-    this.andWhere(new typeorm_2.Brackets((qb) => {
+    this.andWhere(new typeorm_1.Brackets((qb) => {
         for (const item of columnNames) {
             qb.orWhere(`${item} ILIKE :q`);
         }
@@ -61,7 +60,7 @@ typeorm_2.SelectQueryBuilder.prototype.searchByString = function (q, columnNames
     }
     return this;
 };
-typeorm_2.SelectQueryBuilder.prototype.paginate = function (pageOptionsDto, options) {
+typeorm_1.SelectQueryBuilder.prototype.paginate = function (pageOptionsDto, options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!(options === null || options === void 0 ? void 0 : options.takeAll)) {
             this.skip(pageOptionsDto.skip).take(pageOptionsDto.pageSize);
@@ -78,7 +77,7 @@ typeorm_2.SelectQueryBuilder.prototype.paginate = function (pageOptionsDto, opti
         return [entities, pageMetaDto];
     });
 };
-typeorm_2.SelectQueryBuilder.prototype.paginateAndMap = function (pageOptionsDto, options) {
+typeorm_1.SelectQueryBuilder.prototype.paginateAndMap = function (pageOptionsDto, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const [entities, pageMetaDto] = yield this.paginate(pageOptionsDto, {
             skipCount: options === null || options === void 0 ? void 0 : options.skipCount,
@@ -91,7 +90,7 @@ typeorm_2.SelectQueryBuilder.prototype.paginateAndMap = function (pageOptionsDto
         return transformedEntities.toPageDto(pageMetaDto, options === null || options === void 0 ? void 0 : options.dtoOptions);
     });
 };
-typeorm_2.SelectQueryBuilder.prototype.withTenant = function (tenantId, tenantFieldName = 'tenantId') {
+typeorm_1.SelectQueryBuilder.prototype.withTenant = function (tenantId, tenantFieldName = 'tenantId') {
     var _a;
     if (!tenantId) {
         tenantId = providers_1.ContextProvider.getTenantId();
@@ -107,7 +106,7 @@ typeorm_2.SelectQueryBuilder.prototype.withTenant = function (tenantId, tenantFi
     }
     return this;
 };
-typeorm_2.SelectQueryBuilder.prototype.iterate = function (options) {
+typeorm_1.SelectQueryBuilder.prototype.iterate = function (options) {
     return __asyncGenerator(this, arguments, function* () {
         const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
         let offset = 0;
@@ -125,7 +124,7 @@ typeorm_2.SelectQueryBuilder.prototype.iterate = function (options) {
         }
     });
 };
-typeorm_2.SelectQueryBuilder.prototype.eachBatch = function (callback, options) {
+typeorm_1.SelectQueryBuilder.prototype.eachBatch = function (callback, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
         const mode = (options === null || options === void 0 ? void 0 : options.mode) || 'batch';
@@ -151,95 +150,3 @@ typeorm_2.SelectQueryBuilder.prototype.eachBatch = function (callback, options)
         }
     });
 };
-const insertWithPk = function (entity) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!this.metadata) {
-            throw new Error('Repository metadata is not available. Make sure the repository is properly initialized.');
-        }
-        const tableName = this.metadata.tableName;
-        const columns = this.metadata.columns;
-        const columnNames = [];
-        const columnValues = [];
-        const valuePlaceholders = [];
-        for (const column of columns) {
-            const propertyName = column.propertyName;
-            const value = entity[propertyName];
-            if (value === undefined) {
-                continue;
-            }
-            const columnName = column.databaseName;
-            if (columnName) {
-                columnNames.push(columnName);
-                columnValues.push(value);
-                valuePlaceholders.push(`?`);
-            }
-        }
-        const sql = `INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${valuePlaceholders.join(', ')})`;
-        try {
-            const result = yield this.query(sql, columnValues);
-            return result[0];
-        }
-        catch (error) {
-            console.warn(`Native SQL insert failed for ${tableName}, falling back to regular save:`, error);
-            return yield this.save(entity);
-        }
-    });
-};
-typeorm_1.Repository.prototype.getPrimaryKeyFields = function () {
-    if (!this.metadata) {
-        throw new Error('Repository metadata is not available. Make sure the repository is properly initialized.');
-    }
-    const primaryKeys = this.metadata.primaryColumns;
-    if (!primaryKeys || primaryKeys.length === 0) {
-        throw new Error(`Entity ${this.metadata.targetName} does not have any primary key columns defined.`);
-    }
-    return primaryKeys.map(column => column.propertyName);
-};
-typeorm_1.Repository.prototype.saveWithPk = function (entity) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const isArray = Array.isArray(entity);
-        const entities = isArray ? entity : [entity];
-        if (entities.length === 0) {
-            return isArray ? [] : null;
-        }
-        const pkFields = this.getPrimaryKeyFields();
-        const results = yield Promise.all(entities.map((singleEntity) => __awaiter(this, void 0, void 0, function* () {
-            const hasPkValues = pkFields.every(pkField => {
-                const value = singleEntity[pkField];
-                return value !== undefined && value !== null && value !== '';
-            });
-            if (hasPkValues) {
-                try {
-                    const existingEntity = yield this.findOne({
-                        where: pkFields.reduce((acc, pkField) => {
-                            acc[pkField] = singleEntity[pkField];
-                            return acc;
-                        }, {})
-                    });
-                    if (existingEntity) {
-                        yield this.update(pkFields.reduce((acc, pkField) => {
-                            acc[pkField] = singleEntity[pkField];
-                            return acc;
-                        }, {}), singleEntity);
-                        return yield this.findOne({
-                            where: pkFields.reduce((acc, pkField) => {
-                                acc[pkField] = singleEntity[pkField];
-                                return acc;
-                            }, {})
-                        });
-                    }
-                    else {
-                        return yield insertWithPk.call(this, singleEntity);
-                    }
-                }
-                catch (error) {
-                    return yield insertWithPk.call(this, singleEntity);
-                }
-            }
-            else {
-                return yield this.save(singleEntity);
-            }
-        })));
-        return isArray ? results : results[0];
-    });
-};

package/i18n/en_US/validation.json

@@ -40,5 +40,6 @@
     "IS_LOCALE": "{property} value `{value}` must be a valid locale",
     "AT_LEAST_ONE_FIELD": "At least one of the following fields must be provided: {properties}",
     "CUSTOM_VALIDATION": "Custom validation failed for {property}",
-    "CUSTOM_VALIDATION_METHOD": "Validation failed for {property}"
+    "CUSTOM_VALIDATION_METHOD": "Validation failed for {property}",
+    "CUSTOM_VALIDATE": "Validation failed for {property}"
 }

package/i18n/zh_CN/validation.json

@@ -40,5 +40,6 @@
     "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言",
     "AT_LEAST_ONE_FIELD": "以下字段中至少必须提供一个：{properties}",
     "CUSTOM_VALIDATION": "{property}自定义验证失败",
-    "CUSTOM_VALIDATION_METHOD": "{property}验证失败"
+    "CUSTOM_VALIDATION_METHOD": "{property}验证失败",
+    "CUSTOM_VALIDATE": "{property}验证失败"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "4.1.3-1",
+  "version": "4.1.3-2",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",

package/shared/serviceRegistryModule.js

@@ -37,11 +37,15 @@ const nestjs_cls_1 = require("nestjs-cls");
 const redis_lock_1 = require("../redis-lock");
 const typeorm_2 = require("typeorm");
 const vault_1 = require("../vault");
+const validators_1 = require("../validators");
 const providers = [
     services_1.ApiConfigService,
     services_1.ValidatorService,
     services_1.GeneratorService,
     services_1.TranslationService,
+    validators_1.IsExistsValidator,
+    validators_1.IsUniqueValidator,
+    validators_1.CustomValidateValidator,
 ];
 if (!((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.ENV_FILE_PATH)) {
     Promise.resolve().then(() => require('../setup/bootstrap.setup'));

package/validators/custom-validate.examples.d.ts

@@ -0,0 +1,73 @@
+import { Repository } from 'typeorm';
+import { ValidationContext } from '../validators/custom-validate.validator';
+export declare class Example1_InlineValidation {
+    price: number;
+    code: string;
+    maxPrice: number;
+    minPrice: number;
+}
+export declare class Example2_EntityMethod {
+    version: string;
+    publishedAt: Date;
+    createdAt: Date;
+    validateVersion(value: string): boolean;
+    checkDates(value: Date, context: ValidationContext): Promise<boolean>;
+}
+export declare class ExampleValidationService {
+    private readonly userRepository;
+    constructor(userRepository: Repository<any>);
+    usernameAvailable(username: string): Promise<boolean>;
+    validateEmail(email: string): boolean;
+    checkRange(value: number, context: ValidationContext, min: number, max: number): boolean;
+    validateBusinessRule(value: any, context: ValidationContext): Promise<boolean>;
+}
+export declare class Example3_ServiceValidation {
+    username: string;
+    email: string;
+    age: number;
+    businessField: string;
+    userId: string;
+}
+export declare class Example4_LazyReference {
+    username: string;
+}
+export declare class Example5_ComplexValidation {
+    password: string;
+    confirmPassword: string;
+    approverId?: string;
+    requiresApproval: boolean;
+}
+export declare class FileValidationService {
+    private readonly allowedMimeTypes;
+    private readonly maxFileSize;
+    checkFileType(mimeType: string): boolean;
+    checkFileSize(size: number, context: ValidationContext, maxSize?: number): boolean;
+    checkFileHash(hash: string): Promise<boolean>;
+}
+export declare class Example6_FileUpload {
+    mimeType: string;
+    size: number;
+    hash: string;
+}
+export declare class Example7_DynamicMessage {
+    discount: number;
+}
+export declare class ThirdPartyValidationService {
+    validateAddress(address: string): Promise<boolean>;
+    validateTaxId(taxId: string, context: ValidationContext): Promise<boolean>;
+}
+export declare class Example8_ThirdPartyAPI {
+    address: string;
+    taxId: string;
+    country: string;
+}
+export declare class CachedValidationService {
+    private cache;
+    private readonly cacheTTL;
+    expensiveValidation(value: string): Promise<boolean>;
+    private doExpensiveCheck;
+    private cleanExpiredCache;
+}
+export declare class Example9_CachedValidation {
+    field: string;
+}

package/validators/custom-validate.examples.js

@@ -0,0 +1,328 @@
+"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.Example9_CachedValidation = exports.CachedValidationService = exports.Example8_ThirdPartyAPI = exports.ThirdPartyValidationService = exports.Example7_DynamicMessage = exports.Example6_FileUpload = exports.FileValidationService = exports.Example5_ComplexValidation = exports.Example4_LazyReference = exports.Example3_ServiceValidation = exports.ExampleValidationService = exports.Example2_EntityMethod = exports.Example1_InlineValidation = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const custom_validate_validator_1 = require("../validators/custom-validate.validator");
+class Example1_InlineValidation {
+}
+exports.Example1_InlineValidation = Example1_InlineValidation;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value) => value > 0, { message: '价格必须大于0' }),
+    __metadata("design:type", Number)
+], Example1_InlineValidation.prototype, "price", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield fetch(`/api/check/${value}`);
+        return response.ok;
+    }), { message: '验证失败' }),
+    __metadata("design:type", String)
+], Example1_InlineValidation.prototype, "code", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value, context) => {
+        const minValue = context.object.minPrice || 0;
+        return value > minValue;
+    }, { message: '最大价格必须大于最小价格' }),
+    __metadata("design:type", Number)
+], Example1_InlineValidation.prototype, "maxPrice", void 0);
+class Example2_EntityMethod {
+    validateVersion(value) {
+        return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value);
+    }
+    checkDates(value, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return value >= this.createdAt;
+        });
+    }
+}
+exports.Example2_EntityMethod = Example2_EntityMethod;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)('validateVersion', {
+        message: '版本号格式必须为 x.y.z'
+    }),
+    __metadata("design:type", String)
+], Example2_EntityMethod.prototype, "version", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)('checkDates'),
+    __metadata("design:type", Date)
+], Example2_EntityMethod.prototype, "publishedAt", void 0);
+let ExampleValidationService = class ExampleValidationService {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+    usernameAvailable(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const count = yield this.userRepository.count({
+                where: { username }
+            });
+            return count === 0;
+        });
+    }
+    validateEmail(email) {
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+    }
+    checkRange(value, context, min, max) {
+        return value >= min && value <= max;
+    }
+    validateBusinessRule(value, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.userRepository.findOne({
+                where: { id: context.object.userId },
+                relations: ['profile', 'permissions']
+            });
+            if (!user) {
+                return false;
+            }
+            return user.profile.isVerified && user.permissions.length > 0;
+        });
+    }
+};
+exports.ExampleValidationService = ExampleValidationService;
+exports.ExampleValidationService = ExampleValidationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(UserEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], ExampleValidationService);
+class Example3_ServiceValidation {
+}
+exports.Example3_ServiceValidation = Example3_ServiceValidation;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ExampleValidationService, 'usernameAvailable'], { message: '用户名已被使用' }),
+    __metadata("design:type", String)
+], Example3_ServiceValidation.prototype, "username", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ExampleValidationService, 'validateEmail'], { message: '邮箱格式不正确' }),
+    __metadata("design:type", String)
+], Example3_ServiceValidation.prototype, "email", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ExampleValidationService, 'checkRange', 18, 100], { message: '年龄必须在 18-100 之间' }),
+    __metadata("design:type", Number)
+], Example3_ServiceValidation.prototype, "age", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ExampleValidationService, 'validateBusinessRule'], { message: '业务规则验证失败' }),
+    __metadata("design:type", String)
+], Example3_ServiceValidation.prototype, "businessField", void 0);
+class Example4_LazyReference {
+}
+exports.Example4_LazyReference = Example4_LazyReference;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([() => ExampleValidationService, 'usernameAvailable'], { message: '用户名已存在' }),
+    __metadata("design:type", String)
+], Example4_LazyReference.prototype, "username", void 0);
+class Example5_ComplexValidation {
+}
+exports.Example5_ComplexValidation = Example5_ComplexValidation;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value, context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (value.length < 8) {
+            return false;
+        }
+        const hasUpperCase = /[A-Z]/.test(value);
+        const hasLowerCase = /[a-z]/.test(value);
+        const hasNumber = /\d/.test(value);
+        const hasSpecial = /[@$!%*?&]/.test(value);
+        if (!(hasUpperCase && hasLowerCase && hasNumber && hasSpecial)) {
+            return false;
+        }
+        const response = yield fetch(`/api/check-weak-password`, {
+            method: 'POST',
+            body: JSON.stringify({ password: value }),
+            headers: { 'Content-Type': 'application/json' }
+        });
+        const data = yield response.json();
+        return !data.isWeak;
+    }), { message: '密码不符合安全要求：至少8位，包含大小写字母、数字和特殊字符，且不在弱密码列表中' }),
+    __metadata("design:type", String)
+], Example5_ComplexValidation.prototype, "password", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value, context) => {
+        return value === context.object.password;
+    }, { message: '两次密码输入不一致' }),
+    __metadata("design:type", String)
+], Example5_ComplexValidation.prototype, "confirmPassword", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value, context) => {
+        if (context.object.requiresApproval) {
+            return value && value.length > 0;
+        }
+        return true;
+    }, { message: '需要审批时必须指定审批人' }),
+    __metadata("design:type", String)
+], Example5_ComplexValidation.prototype, "approverId", void 0);
+let FileValidationService = class FileValidationService {
+    constructor() {
+        this.allowedMimeTypes = [
+            'image/jpeg',
+            'image/png',
+            'image/gif',
+            'application/pdf'
+        ];
+        this.maxFileSize = 5 * 1024 * 1024;
+    }
+    checkFileType(mimeType) {
+        return this.allowedMimeTypes.includes(mimeType);
+    }
+    checkFileSize(size, context, maxSize) {
+        const limit = maxSize || this.maxFileSize;
+        return size <= limit;
+    }
+    checkFileHash(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+};
+exports.FileValidationService = FileValidationService;
+exports.FileValidationService = FileValidationService = __decorate([
+    (0, common_1.Injectable)()
+], FileValidationService);
+class Example6_FileUpload {
+}
+exports.Example6_FileUpload = Example6_FileUpload;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([FileValidationService, 'checkFileType'], { message: '文件类型不支���，仅支持 JPEG, PNG, GIF, PDF' }),
+    __metadata("design:type", String)
+], Example6_FileUpload.prototype, "mimeType", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([FileValidationService, 'checkFileSize', 10 * 1024 * 1024], { message: '文件大小不能超过 10MB' }),
+    __metadata("design:type", Number)
+], Example6_FileUpload.prototype, "size", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([FileValidationService, 'checkFileHash'], { message: '文件已存在' }),
+    __metadata("design:type", String)
+], Example6_FileUpload.prototype, "hash", void 0);
+class Example7_DynamicMessage {
+}
+exports.Example7_DynamicMessage = Example7_DynamicMessage;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)((value) => value > 0 && value <= 100, {
+        message: (args) => {
+            const value = args.value;
+            if (value <= 0) {
+                return '折扣必须大于 0';
+            }
+            if (value > 100) {
+                return `折扣 ${value}% 超过了最大值 100%`;
+            }
+            return '折扣值无效';
+        }
+    }),
+    __metadata("design:type", Number)
+], Example7_DynamicMessage.prototype, "discount", void 0);
+let ThirdPartyValidationService = class ThirdPartyValidationService {
+    validateAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(address)}`);
+                const data = yield response.json();
+                return data.status === 'OK' && data.results.length > 0;
+            }
+            catch (error) {
+                console.error('Address validation error:', error);
+                return false;
+            }
+        });
+    }
+    validateTaxId(taxId, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`https://api.tax-service.com/validate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ taxId, country: context.object.country })
+                });
+                const data = yield response.json();
+                return data.valid;
+            }
+            catch (error) {
+                console.error('Tax ID validation error:', error);
+                return false;
+            }
+        });
+    }
+};
+exports.ThirdPartyValidationService = ThirdPartyValidationService;
+exports.ThirdPartyValidationService = ThirdPartyValidationService = __decorate([
+    (0, common_1.Injectable)()
+], ThirdPartyValidationService);
+class Example8_ThirdPartyAPI {
+}
+exports.Example8_ThirdPartyAPI = Example8_ThirdPartyAPI;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ThirdPartyValidationService, 'validateAddress'], { message: '地址无效，请输入真实存在的地址' }),
+    __metadata("design:type", String)
+], Example8_ThirdPartyAPI.prototype, "address", void 0);
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([ThirdPartyValidationService, 'validateTaxId'], { message: '税号无效' }),
+    __metadata("design:type", String)
+], Example8_ThirdPartyAPI.prototype, "taxId", void 0);
+let CachedValidationService = class CachedValidationService {
+    constructor() {
+        this.cache = new Map();
+        this.cacheTTL = 5 * 60 * 1000;
+    }
+    expensiveValidation(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const cached = this.cache.get(value);
+            if (cached && (now - cached.timestamp) < this.cacheTTL) {
+                console.log(`[Cache Hit] Value: ${value}`);
+                return cached.result;
+            }
+            console.log(`[Cache Miss] Performing validation for: ${value}`);
+            const result = yield this.doExpensiveCheck(value);
+            this.cache.set(value, { result, timestamp: now });
+            this.cleanExpiredCache();
+            return result;
+        });
+    }
+    doExpensiveCheck(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise(resolve => setTimeout(resolve, 1000));
+            return true;
+        });
+    }
+    cleanExpiredCache() {
+        const now = Date.now();
+        for (const [key, value] of this.cache.entries()) {
+            if (now - value.timestamp >= this.cacheTTL) {
+                this.cache.delete(key);
+            }
+        }
+    }
+};
+exports.CachedValidationService = CachedValidationService;
+exports.CachedValidationService = CachedValidationService = __decorate([
+    (0, common_1.Injectable)()
+], CachedValidationService);
+class Example9_CachedValidation {
+}
+exports.Example9_CachedValidation = Example9_CachedValidation;
+__decorate([
+    (0, custom_validate_validator_1.CustomValidate)([CachedValidationService, 'expensiveValidation'], { message: '验证失败' }),
+    __metadata("design:type", String)
+], Example9_CachedValidation.prototype, "field", void 0);
+class UserEntity {
+}

package/validators/custom-validate.validator.d.ts

@@ -0,0 +1,26 @@
+import type { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
+import { ModuleRef } from '@nestjs/core';
+export interface ValidationContext {
+    value: any;
+    object: any;
+    property: string;
+    constraints: any[];
+    targetName: string;
+    args: ValidationArguments;
+}
+export type ValidatorFunction = (value: any, context: ValidationContext, ...extraArgs: any[]) => boolean | Promise<boolean>;
+export type ValidationConstraint = ValidatorFunction | string | [Function | (() => Function), string, ...any[]];
+export interface CustomValidateOptions extends ValidationOptions {
+    message?: string | ((args: ValidationArguments) => string);
+    async?: boolean;
+}
+export declare class CustomValidateValidator implements ValidatorConstraintInterface {
+    private readonly moduleRef;
+    constructor(moduleRef: ModuleRef);
+    validate(value: any, args: ValidationArguments): Promise<boolean>;
+    private callFunction;
+    private callEntityMethod;
+    private callServiceMethod;
+    defaultMessage(args: ValidationArguments): string;
+}
+export declare function CustomValidate(constraint: ValidationConstraint, validationOptions?: CustomValidateOptions): PropertyDecorator;

package/validators/custom-validate.validator.js

@@ -0,0 +1,129 @@
+"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 __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.CustomValidateValidator = void 0;
+exports.CustomValidate = CustomValidate;
+const class_validator_1 = require("class-validator");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const nestjs_i18n_1 = require("nestjs-i18n");
+let CustomValidateValidator = class CustomValidateValidator {
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
+    validate(value, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [constraint, ...extraArgs] = args.constraints;
+            const context = {
+                value,
+                object: args.object,
+                property: args.property,
+                constraints: args.constraints,
+                targetName: args.targetName,
+                args,
+            };
+            try {
+                if (typeof constraint === 'function') {
+                    return yield this.callFunction(constraint, value, context, extraArgs);
+                }
+                if (typeof constraint === 'string') {
+                    return yield this.callEntityMethod(args.object, constraint, value, context, extraArgs);
+                }
+                if (Array.isArray(constraint)) {
+                    return yield this.callServiceMethod(constraint, value, context);
+                }
+                throw new Error(`[@CustomValidate] Invalid constraint type for property "${args.property}". ` +
+                    `Expected: function, string, or array. Got: ${typeof constraint}`);
+            }
+            catch (error) {
+                console.error(`[@CustomValidate] Validation error for property "${args.property}":`, error);
+                throw error;
+            }
+        });
+    }
+    callFunction(fn, value, context, extraArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = fn(value, context, ...extraArgs);
+            return result instanceof Promise ? yield result : result;
+        });
+    }
+    callEntityMethod(entity, methodName, value, context, extraArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!entity || typeof entity[methodName] !== 'function') {
+                throw new Error(`[@CustomValidate] Method "${methodName}" not found on entity "${context.targetName}". ` +
+                    `Make sure the method exists and is accessible.`);
+            }
+            const result = entity[methodName](value, context, ...extraArgs);
+            return result instanceof Promise ? yield result : result;
+        });
+    }
+    callServiceMethod(constraint, value, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let [serviceClass, methodName, ...extraArgs] = constraint;
+            if (!serviceClass || !methodName) {
+                throw new Error(`[@CustomValidate] Invalid service constraint format. ` +
+                    `Expected: [ServiceClass, 'methodName'] or [() => ServiceClass, 'methodName']`);
+            }
+            if (typeof serviceClass === 'function' && !serviceClass.prototype) {
+                serviceClass = serviceClass();
+            }
+            if (!serviceClass) {
+                throw new Error(`[@CustomValidate] Service class is undefined. ` +
+                    `This may be caused by circular dependencies. ` +
+                    `Consider using lazy reference: [() => ServiceClass, 'methodName']`);
+            }
+            let service;
+            try {
+                service = this.moduleRef.get(serviceClass, { strict: false });
+            }
+            catch (error) {
+                throw new Error(`[@CustomValidate] Failed to resolve service "${serviceClass.name}". ` +
+                    `Make sure the service is registered as a provider in a NestJS module. ` +
+                    `Error: ${error.message}`);
+            }
+            if (!service || typeof service[methodName] !== 'function') {
+                throw new Error(`[@CustomValidate] Method "${methodName}" not found on service "${serviceClass.name}". ` +
+                    `Available methods: ${Object.getOwnPropertyNames(Object.getPrototypeOf(service)).join(', ')}`);
+            }
+            const result = service[methodName](value, context, ...extraArgs);
+            return result instanceof Promise ? yield result : result;
+        });
+    }
+    defaultMessage(args) {
+        return (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATE')(args);
+    }
+};
+exports.CustomValidateValidator = CustomValidateValidator;
+exports.CustomValidateValidator = CustomValidateValidator = __decorate([
+    (0, common_1.Injectable)(),
+    (0, class_validator_1.ValidatorConstraint)({ name: 'customValidate', async: true }),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
+], CustomValidateValidator);
+function CustomValidate(constraint, validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: [constraint],
+            validator: CustomValidateValidator,
+        });
+    };
+}

package/validators/index.d.ts

@@ -4,3 +4,4 @@ export * from './file-mimetype.validator';
 export * from './is-exists.validator';
 export * from './is-unique.validator';
 export * from './same-as.validator';
+export * from './custom-validate.validator';

package/validators/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./file-mimetype.validator"), exports);
 __exportStar(require("./is-exists.validator"), exports);
 __exportStar(require("./is-unique.validator"), exports);
 __exportStar(require("./same-as.validator"), exports);
+__exportStar(require("./custom-validate.validator"), exports);

package/validators/is-exists.validator.d.ts

@@ -1,14 +1,17 @@
 import type { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
 import type { EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
-import { DataSource } from 'typeorm';
+import { TransactionHost } from '@nestjs-cls/transactional';
+import { TransactionalAdapterTypeOrm } from '@nestjs-cls/transactional-adapter-typeorm';
 export declare class IsExistsValidator implements ValidatorConstraintInterface {
-    private readonly dataSource;
-    constructor(dataSource: DataSource);
+    private readonly transactionHost;
+    constructor(transactionHost: TransactionHost<TransactionalAdapterTypeOrm>);
+    private resolveEntity;
+    private inferEntityNameFromProperty;
     validate<E>(value: string, args: IExistsValidationArguments<E>): Promise<boolean>;
     defaultMessage(args: ValidationArguments): string;
 }
 type ExistsValidationConstraints<E> = [
-    ObjectType<E> | EntitySchema<E> | string,
+    ObjectType<E> | EntitySchema<E> | string | (() => ObjectType<E> | EntitySchema<E> | string),
     (validationArguments: ValidationArguments) => FindOptionsWhere<E>
 ];
 interface IExistsValidationArguments<E> extends ValidationArguments {

package/validators/is-exists.validator.js

@@ -21,18 +21,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsExistsValidator = void 0;
 exports.IsExists = IsExists;
 const class_validator_1 = require("class-validator");
-const typeorm_1 = require("typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const common_1 = require("@nestjs/common");
+const transactional_1 = require("@nestjs-cls/transactional");
 let IsExistsValidator = class IsExistsValidator {
-    constructor(dataSource) {
-        this.dataSource = dataSource;
+    constructor(transactionHost) {
+        this.transactionHost = transactionHost;
+    }
+    resolveEntity(entityRef, propertyName, object) {
+        if (typeof entityRef === 'string') {
+            return entityRef;
+        }
+        if (typeof entityRef === 'function') {
+            if (!entityRef.prototype) {
+                const resolved = entityRef();
+                if (resolved)
+                    return resolved;
+            }
+            else {
+                return entityRef;
+            }
+        }
+        if (!entityRef) {
+            const inferredEntityName = this.inferEntityNameFromProperty(propertyName);
+            if (inferredEntityName) {
+                console.warn(`[IsExists] Entity reference is undefined for property "${propertyName}". ` +
+                    `This may be caused by circular dependencies. ` +
+                    `Consider using lazy reference: () => ${inferredEntityName}`);
+                return inferredEntityName;
+            }
+        }
+        throw new Error(`[IsExists] Cannot resolve entity reference for property "${propertyName}". ` +
+            `Entity is undefined. This is likely caused by circular dependencies. ` +
+            `Please use one of the following solutions:\n` +
+            `1. Lazy reference: @IsExists([() => EntityClass, ...])\n` +
+            `2. String reference: @IsExists(["EntityName", ...])\n` +
+            `3. Break the circular dependency`);
+    }
+    inferEntityNameFromProperty(propertyName) {
+        const name = propertyName.replace(/(Id|Ids|Key|Code)$/, '');
+        if (!name)
+            return null;
+        const entityName = name.charAt(0).toUpperCase() + name.slice(1) + 'Entity';
+        return entityName;
     }
     validate(value, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [entityClass, findCondition] = args.constraints;
+            const [entityRef, findCondition] = args.constraints;
+            const entityClass = this.resolveEntity(entityRef, args.property, args.object);
+            const repository = this.transactionHost.tx.getRepository(entityClass);
             args.value = value;
-            return ((yield this.dataSource.getRepository(entityClass).count({
+            return ((yield repository.count({
                 where: findCondition(args),
             })) > 0);
         });
@@ -45,7 +84,7 @@ exports.IsExistsValidator = IsExistsValidator;
 exports.IsExistsValidator = IsExistsValidator = __decorate([
     (0, common_1.Injectable)(),
     (0, class_validator_1.ValidatorConstraint)({ name: 'isExists', async: true }),
-    __metadata("design:paramtypes", [typeorm_1.DataSource])
+    __metadata("design:paramtypes", [transactional_1.TransactionHost])
 ], IsExistsValidator);
 function IsExists(constraints, validationOptions) {
     return (object, propertyName) => {

package/validators/is-unique.validator.d.ts

@@ -1,13 +1,17 @@
 import type { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
-import { DataSource, EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
+import { EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
+import { TransactionHost } from '@nestjs-cls/transactional';
+import { TransactionalAdapterTypeOrm } from '@nestjs-cls/transactional-adapter-typeorm';
 export declare class IsUniqueValidator implements ValidatorConstraintInterface {
-    private readonly dataSource;
-    constructor(dataSource: DataSource);
+    private readonly transactionHost;
+    constructor(transactionHost: TransactionHost<TransactionalAdapterTypeOrm>);
+    private resolveEntity;
+    private inferEntityNameFromProperty;
     validate<E>(value: string, args: IUniqueValidationArguments<E>): Promise<boolean>;
     defaultMessage(args: ValidationArguments): string;
 }
 type UniqueValidationConstraints<E> = [
-    ObjectType<E> | EntitySchema<E> | string,
+    ObjectType<E> | EntitySchema<E> | string | (() => ObjectType<E> | EntitySchema<E> | string),
     (validationArguments: ValidationArguments) => FindOptionsWhere<E>
 ];
 interface IUniqueValidationArguments<E> extends ValidationArguments {

package/validators/is-unique.validator.js

@@ -21,31 +21,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUniqueValidator = void 0;
 exports.IsUnique = IsUnique;
 const class_validator_1 = require("class-validator");
-const typeorm_1 = require("typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
+const common_1 = require("@nestjs/common");
+const transactional_1 = require("@nestjs-cls/transactional");
 let IsUniqueValidator = class IsUniqueValidator {
-    constructor(dataSource) {
-        this.dataSource = dataSource;
+    constructor(transactionHost) {
+        this.transactionHost = transactionHost;
+    }
+    resolveEntity(entityRef, propertyName, object) {
+        if (typeof entityRef === 'string') {
+            return entityRef;
+        }
+        if (typeof entityRef === 'function') {
+            if (!entityRef.prototype) {
+                const resolved = entityRef();
+                if (resolved)
+                    return resolved;
+            }
+            else {
+                return entityRef;
+            }
+        }
+        if (!entityRef) {
+            const inferredEntityName = this.inferEntityNameFromProperty(propertyName);
+            if (inferredEntityName) {
+                console.warn(`[IsUnique] Entity reference is undefined for property "${propertyName}". ` +
+                    `This may be caused by circular dependencies. ` +
+                    `Consider using lazy reference: () => ${inferredEntityName}`);
+                return inferredEntityName;
+            }
+        }
+        throw new Error(`[IsUnique] Cannot resolve entity reference for property "${propertyName}". ` +
+            `Entity is undefined. This is likely caused by circular dependencies. ` +
+            `Please use one of the following solutions:\n` +
+            `1. Lazy reference: @IsUnique([() => EntityClass, ...])\n` +
+            `2. String reference: @IsUnique(["EntityName", ...])\n` +
+            `3. Break the circular dependency`);
+    }
+    inferEntityNameFromProperty(propertyName) {
+        const name = propertyName.replace(/(Id|Ids|Key|Code)$/, '');
+        if (!name)
+            return null;
+        const entityName = name.charAt(0).toUpperCase() + name.slice(1) + 'Entity';
+        return entityName;
     }
     validate(value, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [entityClass, findCondition] = args.constraints;
+            const [entityRef, findCondition] = args.constraints;
+            const entityClass = this.resolveEntity(entityRef, args.property, args.object);
+            const repository = this.transactionHost.tx.getRepository(entityClass);
             args.value = value;
             let exists;
             const defCon = findCondition(args);
-            const pkCols = this.dataSource
-                .getMetadata(entityClass)
+            const pkCols = repository.metadata
                 .primaryColumns.map((column) => column.propertyName);
             const isNew = pkCols.some((pk) => args.object[pk]);
             if (!isNew) {
                 exists =
-                    (yield this.dataSource
-                        .getRepository(entityClass)
+                    (yield repository
                         .count({ where: defCon })) < 1;
             }
             else {
-                const entities = yield this.dataSource
-                    .getRepository(entityClass)
+                const entities = yield repository
                     .createQueryBuilder()
                     .where(defCon)
                     .select(pkCols)
@@ -75,8 +112,9 @@ let IsUniqueValidator = class IsUniqueValidator {
 };
 exports.IsUniqueValidator = IsUniqueValidator;
 exports.IsUniqueValidator = IsUniqueValidator = __decorate([
+    (0, common_1.Injectable)(),
     (0, class_validator_1.ValidatorConstraint)({ name: 'isUnique', async: true }),
-    __metadata("design:paramtypes", [typeorm_1.DataSource])
+    __metadata("design:paramtypes", [transactional_1.TransactionHost])
 ], IsUniqueValidator);
 function IsUnique(constraints, validationOptions) {
     return function (object, propertyName) {