@nest-omni/core 3.1.1-17 → 3.1.1-19

package/decorators/examples/validation-decorators.example.d.ts

@@ -0,0 +1,69 @@
+export declare class ContactDto {
+    email?: string;
+    phone?: string;
+    wechat?: string;
+}
+export declare class SearchDto {
+    keyword?: string;
+    category?: string;
+    tags?: string[];
+}
+export declare class PasswordDto {
+    password: string;
+}
+export declare class EmailCheckDto {
+    email: string;
+    userService?: any;
+}
+export declare class OrderDto {
+    orderType: 'standard' | 'express';
+    deliveryDate?: Date;
+}
+export declare class DiscountDto {
+    discountType: 'percentage' | 'fixed';
+    discountValue: number;
+    get validatedDiscountValue(): number;
+}
+export declare class UserRegistrationDto {
+    username: string;
+    password: string;
+    confirmPassword: string;
+    validatePassword(password: string): boolean;
+    validatePasswordMatch(confirmPassword: string): boolean;
+}
+export declare class CreateProductDto {
+    name: string;
+    sku: string;
+    categoryId: string;
+    get validatedCategoryId(): string;
+    productService?: any;
+    categoryService?: any;
+    checkSkuUniqueness(sku: string): Promise<boolean>;
+    validateCategoryExists(categoryId: string): Promise<boolean>;
+}
+export declare class EmployeeDto {
+    name: string;
+    personalEmail?: string;
+    workEmail?: string;
+    phone?: string;
+    validatePhoneFormat(phone: string): boolean;
+}
+export declare class PaymentMethodDto {
+    paymentType: 'credit_card' | 'bank_transfer' | 'digital_wallet';
+    creditCard?: {
+        number: string;
+        expiryDate: string;
+        cvv: string;
+    };
+    bankAccount?: {
+        accountNumber: string;
+        routingNumber: string;
+    };
+    digitalWallet?: {
+        provider: string;
+        walletId: string;
+    };
+    validateCreditCard(creditCard: any): boolean;
+    validateBankAccount(bankAccount: any): boolean;
+    validateDigitalWallet(digitalWallet: any): boolean;
+}

package/decorators/examples/validation-decorators.example.js

@@ -0,0 +1,331 @@
+"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.PaymentMethodDto = exports.EmployeeDto = exports.CreateProductDto = exports.UserRegistrationDto = exports.DiscountDto = exports.OrderDto = exports.EmailCheckDto = exports.PasswordDto = exports.SearchDto = exports.ContactDto = void 0;
+const class_validator_1 = require("class-validator");
+const swagger_1 = require("@nestjs/swagger");
+const validator_decorators_1 = require("../validator.decorators");
+const field_decorators_1 = require("../field.decorators");
+class ContactDto {
+}
+exports.ContactDto = ContactDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsEmail)(),
+    (0, validator_decorators_1.AtLeastOneField)(['email', 'phone', 'wechat']),
+    __metadata("design:type", String)
+], ContactDto.prototype, "email", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ContactDto.prototype, "phone", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ContactDto.prototype, "wechat", void 0);
+class SearchDto {
+}
+exports.SearchDto = SearchDto;
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)(),
+    (0, validator_decorators_1.AtLeastOneField)(['keyword', 'category', 'tags'], {
+        message: 'Please provide at least one search criteria: keyword, category, or tags',
+    }),
+    __metadata("design:type", String)
+], SearchDto.prototype, "keyword", void 0);
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)(),
+    __metadata("design:type", String)
+], SearchDto.prototype, "category", void 0);
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)({ each: true }),
+    __metadata("design:type", Array)
+], SearchDto.prototype, "tags", void 0);
+class PasswordDto {
+}
+exports.PasswordDto = PasswordDto;
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        if (!value || value.length < 8)
+            return false;
+        const hasUppercase = /[A-Z]/.test(value);
+        const hasLowercase = /[a-z]/.test(value);
+        const hasNumber = /[0-9]/.test(value);
+        return hasUppercase && hasLowercase && hasNumber;
+    }, {
+        message: 'Password must be at least 8 characters with uppercase, lowercase, and number',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], PasswordDto.prototype, "password", void 0);
+class EmailCheckDto {
+}
+exports.EmailCheckDto = EmailCheckDto;
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => __awaiter(void 0, void 0, void 0, function* () {
+        const userService = args.object.userService;
+        if (!userService) {
+            console.warn('UserService not found, skipping email check');
+            return true;
+        }
+        const exists = yield userService.checkEmailExists(value);
+        return !exists;
+    }), {
+        message: 'Email already exists in the system',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], EmailCheckDto.prototype, "email", void 0);
+class OrderDto {
+}
+exports.OrderDto = OrderDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: ['standard', 'express'] }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], OrderDto.prototype, "orderType", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => {
+        const object = args.object;
+        if (object.orderType === 'express') {
+            return value !== null && value !== undefined;
+        }
+        return true;
+    }, {
+        message: 'Delivery date is required for express orders',
+    }),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Date)
+], OrderDto.prototype, "deliveryDate", void 0);
+class DiscountDto {
+    get validatedDiscountValue() {
+        return this.discountValue;
+    }
+}
+exports.DiscountDto = DiscountDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], DiscountDto.prototype, "discountType", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], DiscountDto.prototype, "discountValue", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => {
+        const object = args.object;
+        if (object.discountType === 'percentage') {
+            return value >= 0 && value <= 100;
+        }
+        else if (object.discountType === 'fixed') {
+            return value > 0;
+        }
+        return false;
+    }, {
+        message: 'Invalid discount value for the selected discount type',
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], DiscountDto.prototype, "validatedDiscountValue", null);
+class UserRegistrationDto {
+    validatePassword(password) {
+        if (!password || password.length < 8)
+            return false;
+        const hasUppercase = /[A-Z]/.test(password);
+        const hasLowercase = /[a-z]/.test(password);
+        const hasNumber = /[0-9]/.test(password);
+        const hasSpecial = /[!@#$%^&*]/.test(password);
+        return hasUppercase && hasLowercase && hasNumber && hasSpecial;
+    }
+    validatePasswordMatch(confirmPassword) {
+        return confirmPassword === this.password;
+    }
+}
+exports.UserRegistrationDto = UserRegistrationDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "username", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePassword', {
+        message: 'Password does not meet security requirements',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "password", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePasswordMatch'),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "confirmPassword", void 0);
+class CreateProductDto {
+    get validatedCategoryId() {
+        return this.categoryId;
+    }
+    checkSkuUniqueness(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.productService) {
+                console.warn('ProductService not found');
+                return true;
+            }
+            const exists = yield this.productService.skuExists(sku);
+            return !exists;
+        });
+    }
+    validateCategoryExists(categoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.categoryService) {
+                console.warn('CategoryService not found');
+                return true;
+            }
+            return yield this.categoryService.exists(categoryId);
+        });
+    }
+}
+exports.CreateProductDto = CreateProductDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "name", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('checkSkuUniqueness', {
+        message: 'SKU already exists',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "sku", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "categoryId", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateCategoryExists', {
+        message: 'Category does not exist',
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], CreateProductDto.prototype, "validatedCategoryId", null);
+class EmployeeDto {
+    validatePhoneFormat(phone) {
+        if (!phone)
+            return true;
+        const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+        return phoneRegex.test(phone);
+    }
+}
+exports.EmployeeDto = EmployeeDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "name", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        const workDomains = ['company.com', 'corp.com'];
+        const domain = value === null || value === void 0 ? void 0 : value.split('@')[1];
+        return !workDomains.includes(domain);
+    }, {
+        message: 'Personal email should not be from work domains',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, validator_decorators_1.AtLeastOneField)(['personalEmail', 'workEmail']),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "personalEmail", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        const workDomains = ['company.com', 'corp.com'];
+        const domain = value === null || value === void 0 ? void 0 : value.split('@')[1];
+        return workDomains.includes(domain);
+    }, {
+        message: 'Work email must be from company domains',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "workEmail", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePhoneFormat'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "phone", void 0);
+class PaymentMethodDto {
+    validateCreditCard(creditCard) {
+        var _a;
+        if (!creditCard)
+            return true;
+        const number = (_a = creditCard.number) === null || _a === void 0 ? void 0 : _a.replace(/\s/g, '');
+        if (!/^\d{13,19}$/.test(number))
+            return false;
+        let sum = 0;
+        let isEven = false;
+        for (let i = number.length - 1; i >= 0; i--) {
+            let digit = parseInt(number[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    }
+    validateBankAccount(bankAccount) {
+        if (!bankAccount)
+            return true;
+        const accountValid = /^\d{8,17}$/.test(bankAccount.accountNumber);
+        const routingValid = /^\d{9}$/.test(bankAccount.routingNumber);
+        return accountValid && routingValid;
+    }
+    validateDigitalWallet(digitalWallet) {
+        var _a;
+        if (!digitalWallet)
+            return true;
+        const validProviders = ['paypal', 'alipay', 'wechat_pay', 'apple_pay'];
+        return validProviders.includes((_a = digitalWallet.provider) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+    }
+}
+exports.PaymentMethodDto = PaymentMethodDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], PaymentMethodDto.prototype, "paymentType", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateCreditCard'),
+    (0, validator_decorators_1.AtLeastOneField)(['creditCard', 'bankAccount', 'digitalWallet']),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "creditCard", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateBankAccount'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "bankAccount", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateDigitalWallet'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "digitalWallet", void 0);

package/decorators/validator.decorators.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationOptions } from 'class-validator';
-import { IsPhoneNumber as isPhoneNumber } from 'class-validator';
+import { IsPhoneNumber as isPhoneNumber, ValidationArguments, ValidatorConstraintInterface } from 'class-validator';
 export declare function IsPassword(validationOptions?: ValidationOptions): PropertyDecorator;
 export declare function IsPhoneNumber(validationOptions?: ValidationOptions & {
     region?: Parameters<typeof isPhoneNumber>[0];
@@ -9,3 +9,10 @@ export declare function IsUndefinable(options?: ValidationOptions): PropertyDeco
 export declare function IsEmptyable(options?: ValidationOptions): PropertyDecorator;
 export declare function IsNullable(options?: ValidationOptions): PropertyDecorator;
 export declare function IsHttpUrl(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare class AtLeastOneFieldConstraint implements ValidatorConstraintInterface {
+    validate(value: any, args: ValidationArguments): boolean;
+    defaultMessage(args: ValidationArguments): string;
+}
+export declare function AtLeastOneField(properties: string[], validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidation<T = any>(validationCallback: (value: T, args: ValidationArguments) => boolean | Promise<boolean>, validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidationMethod(methodName: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/decorators/validator.decorators.js

@@ -1,5 +1,21 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtLeastOneFieldConstraint = void 0;
 exports.IsPassword = IsPassword;
 exports.IsPhoneNumber = IsPhoneNumber;
 exports.IsTmpKey = IsTmpKey;
@@ -7,8 +23,12 @@ exports.IsUndefinable = IsUndefinable;
 exports.IsEmptyable = IsEmptyable;
 exports.IsNullable = IsNullable;
 exports.IsHttpUrl = IsHttpUrl;
+exports.AtLeastOneField = AtLeastOneField;
+exports.CustomValidation = CustomValidation;
+exports.CustomValidationMethod = CustomValidationMethod;
 const class_validator_1 = require("class-validator");
 const lodash_1 = require("lodash");
+const nestjs_i18n_1 = require("nestjs-i18n");
 function IsPassword(validationOptions) {
     return (object, propertyName) => {
         (0, class_validator_1.registerDecorator)({
@@ -76,3 +96,98 @@ function IsHttpUrl(validationOptions) {
         });
     };
 }
+let AtLeastOneFieldConstraint = class AtLeastOneFieldConstraint {
+    validate(value, args) {
+        const object = args.object;
+        const [requiredProperties] = args.constraints;
+        return requiredProperties.some((property) => {
+            const propValue = object[property];
+            return (propValue !== null &&
+                propValue !== undefined &&
+                propValue !== '' &&
+                !(Array.isArray(propValue) && propValue.length === 0));
+        });
+    }
+    defaultMessage(args) {
+        const [requiredProperties] = args.constraints;
+        return `At least one of the following fields must be provided: ${requiredProperties.join(', ')}`;
+    }
+};
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint;
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'atLeastOneField', async: false })
+], AtLeastOneFieldConstraint);
+function AtLeastOneField(properties, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName: propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.AT_LEAST_ONE_FIELD', {
+                    properties: properties.join(', '),
+                }) }, validationOptions),
+            constraints: [properties],
+            validator: AtLeastOneFieldConstraint,
+        });
+    };
+}
+function CustomValidation(validationCallback, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidation',
+            target: object.constructor,
+            propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            return yield validationCallback(value, args);
+                        }
+                        catch (error) {
+                            console.error('CustomValidation error:', error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    return `Validation failed for ${args.property}`;
+                },
+            },
+        });
+    };
+}
+function CustomValidationMethod(methodName, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidationMethod',
+            target: object.constructor,
+            propertyName,
+            constraints: [methodName],
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION_METHOD') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const [method] = args.constraints;
+                        const object = args.object;
+                        if (typeof object[method] !== 'function') {
+                            console.error(`CustomValidationMethod: Method '${method}' not found on object`);
+                            return false;
+                        }
+                        try {
+                            const result = yield object[method](value, args);
+                            return Boolean(result);
+                        }
+                        catch (error) {
+                            console.error(`CustomValidationMethod error in '${method}':`, error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    const [method] = args.constraints;
+                    return `Validation failed for ${args.property} using method ${method}`;
+                },
+            },
+        });
+    };
+}

package/i18n/en_US/validation.json

@@ -37,5 +37,8 @@
     "IS_IP": "{property} value `{value}` not a valid IP",
     "IS_OBJECT": "{property} value `{value}` not a valid Object",
     "IS_TIME_ZONE": "{property} value `{value}` must be a valid IANA time-zone",
-    "IS_LOCALE": "{property} value `{value}` must be a valid locale"
+    "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}"
 }

package/i18n/zh_CN/validation.json

@@ -37,5 +37,8 @@
     "IS_IP": "{property} 值 `{value}` 必须是有效IP",
     "IS_OBJECT": "{property} 值 `{value}` 必须是有效对象",
     "IS_TIME_ZONE": "{property} 值 `{value}` 必须是有效时区",
-    "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言"
+    "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言",
+    "AT_LEAST_ONE_FIELD": "以下字段中至少必须提供一个：{properties}",
+    "CUSTOM_VALIDATION": "{property}自定义验证失败",
+    "CUSTOM_VALIDATION_METHOD": "{property}验证失败"
 }

package/index.d.ts

@@ -11,6 +11,7 @@ export * from './common';
 export * from './validator-json';
 export * from './helpers';
 export * from './providers';
+export * from './redis-lock';
 export * from './cache';
 export * from './vault';
 export * from './setup';

package/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./validator-json"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./providers"), exports);
+__exportStar(require("./redis-lock"), exports);
 __exportStar(require("./cache"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./setup"), exports);

package/package.json

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

package/redis-lock/examples/lock-strategy.examples.d.ts

@@ -0,0 +1,73 @@
+import { RedisLockService } from '../index';
+export declare class SkipStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    scheduledTask(): Promise<void>;
+    processWithSkip(): Promise<{
+        skipped: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        skipped?: undefined;
+    }>;
+    processWithRetries(): Promise<{
+        skipped: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        skipped?: undefined;
+    }>;
+    private simulateLongRunning;
+}
+export declare class ThrowStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    criticalOperation(): Promise<void>;
+    processWithThrow(): Promise<{
+        success: boolean;
+    }>;
+    processPayment(orderId: string, amount: number): Promise<{
+        success: boolean;
+    }>;
+    private processData;
+    private chargePayment;
+    private updateOrderStatus;
+}
+export declare class WaitStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    sequentialTask(): Promise<void>;
+    processWithWaitTimeout(): Promise<{
+        timeout: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        timeout?: undefined;
+    }>;
+    processDataSequentially(userId: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    processQueue(queueName: string, item: any): Promise<{
+        success: boolean;
+    }>;
+    runMigration(migrationName: string): Promise<{
+        success: boolean;
+    }>;
+    private processInOrder;
+    private validateData;
+    private saveData;
+    private notifyUser;
+    private processQueueItem;
+    private executeMigration;
+}
+export declare class CombinedStrategiesExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    cleanupOldData(): Promise<void>;
+    processPayment(orderId: string): Promise<void>;
+    generateReport(reportId: string): Promise<void>;
+}