@nest-omni/core 3.1.1-9 → 3.1.1

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/field.decorators.d.ts

@@ -0,0 +1,79 @@
+import type { ApiPropertyOptions } from '@nestjs/swagger';
+import * as ValidatorJS from 'validator';
+type RequireField<T, K extends keyof T> = T & Required<Pick<T, K>>;
+interface IFieldOptions {
+    each?: boolean;
+    swagger?: boolean;
+    nullable?: boolean;
+    group?: string[];
+    message?: string;
+}
+interface INumberFieldOptions extends IFieldOptions {
+    min?: number;
+    max?: number;
+    int?: boolean;
+    isPositive?: boolean;
+}
+interface IDateFieldOptions extends IFieldOptions {
+    minDate?: Date | (() => Date);
+    maxDate?: Date | (() => Date);
+}
+interface IStringFieldOptions extends IFieldOptions {
+    minLength?: number;
+    maxLength?: number;
+    toLowerCase?: boolean;
+    toUpperCase?: boolean;
+}
+interface IEmailFieldOptions {
+    emailOptions?: ValidatorJS.IsEmailOptions;
+}
+interface IIPFieldOptions {
+    version?: ValidatorJS.IPVersion;
+}
+interface IURLFieldOptions {
+    urlOptions?: ValidatorJS.IsURLOptions;
+    simpleUrl?: boolean;
+}
+interface IFQDNFieldOptions extends ValidatorJS.IsFQDNOptions {
+}
+type IClassFieldOptions = IFieldOptions;
+type IBooleanFieldOptions = IFieldOptions;
+type IEnumFieldOptions = IFieldOptions;
+export declare function NumberField(options?: Omit<ApiPropertyOptions, 'type'> & INumberFieldOptions): PropertyDecorator;
+export declare function NumberFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & INumberFieldOptions): PropertyDecorator;
+export declare function StringField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function StringFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IStringFieldOptions): PropertyDecorator;
+export declare function PasswordField(options?: Omit<ApiPropertyOptions, 'type' | 'minLength'> & IStringFieldOptions): PropertyDecorator;
+export declare function PasswordFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'minLength'> & IStringFieldOptions): PropertyDecorator;
+export declare function BooleanField(options?: Omit<ApiPropertyOptions, 'type'> & IBooleanFieldOptions): PropertyDecorator;
+export declare function BooleanFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IBooleanFieldOptions): PropertyDecorator;
+export declare function TranslationsField(options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function TranslationsFieldOptional(options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function TmpKeyField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function TmpKeyFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IStringFieldOptions): PropertyDecorator;
+export declare function getEnumDescription(enumType: any): string;
+export declare function EnumField<TEnum extends object>(getEnum: () => TEnum, options?: Omit<ApiPropertyOptions, 'type' | 'enum' | 'enumName' | 'isArray'> & IEnumFieldOptions): PropertyDecorator;
+export declare function ClassField<TClass extends object>(getClass: () => TClass, options?: Omit<ApiPropertyOptions, 'type'> & IClassFieldOptions): PropertyDecorator;
+export declare function EnumFieldOptional<TEnum extends object>(getEnum: () => TEnum, options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'enum' | 'enumName'> & IEnumFieldOptions): PropertyDecorator;
+export declare function ClassFieldOptional<TClass extends object>(getClass: () => TClass, options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IClassFieldOptions): PropertyDecorator;
+export declare function EmailField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IEmailFieldOptions): PropertyDecorator;
+export declare function EmailFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IEmailFieldOptions): PropertyDecorator;
+export declare function PhoneField(options?: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function PhoneFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IFieldOptions): PropertyDecorator;
+export declare function UUIDField(options?: Omit<ApiPropertyOptions, 'type' | 'format' | 'isArray'> & IFieldOptions): PropertyDecorator;
+export declare function UUIDFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'isArray'> & IFieldOptions): PropertyDecorator;
+export declare function URLField(options?: Omit<ApiPropertyOptions, 'type'> & IURLFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function URLFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IURLFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function FQDNField(options?: Omit<ApiPropertyOptions, 'type'> & IFQDNFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function FQDNFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IFQDNFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function DateField(options?: Omit<ApiPropertyOptions, 'type'> & IDateFieldOptions): PropertyDecorator;
+export declare function DateFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IDateFieldOptions): PropertyDecorator;
+export declare function IpFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IIPFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function IpField(options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IIPFieldOptions): PropertyDecorator;
+export declare function ObjectField(options?: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function ObjectFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function TimeZoneField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function TimeZoneFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function LocaleField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function LocaleFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export {};