@dangao/bun-server 1.7.0 → 1.8.0

package/src/validation/index.ts

@@ -1,3 +1,4 @@
+// 基础装饰器
 export {
   Validate,
   IsString,
@@ -7,8 +8,109 @@ export {
   MinLength,
   getValidationMetadata,
 } from './decorators';
-export type { ValidationRuleDefinition, ValidationMetadata } from './types';
+
+// 类型定义
+export type {
+  ValidationRuleDefinition,
+  ValidationMetadata,
+  ClassValidationMetadata,
+  ValidationOptions,
+} from './types';
+
+// 验证器
 export { validateParameters } from './validator';
+
+// 错误处理
 export { ValidationError, type ValidationIssue } from './errors';
 
+// 验证规则 - 对象
+export {
+  IsObject,
+  IsNotEmpty,
+  IsNotEmptyObject,
+  ValidateNested,
+  type ObjectRuleOptions,
+  type ValidateNestedOptions,
+} from './rules/object';
+
+// 验证规则 - 数组
+export {
+  IsArray,
+  ArrayMinSize,
+  ArrayMaxSize,
+  ArrayUnique,
+  ArrayContains,
+  ArrayNotContains,
+  ArrayNotEmpty,
+  type ArrayRuleOptions,
+} from './rules/array';
+
+// 验证规则 - 通用
+export {
+  IsBoolean,
+  IsInt,
+  IsPositive,
+  IsNegative,
+  Min,
+  Max,
+  IsDate,
+  IsUUID,
+  Length,
+  MaxLength,
+  Matches,
+  IsIn,
+  IsNotIn,
+  IsUrl,
+  IsJSON,
+  Equals,
+  NotEquals,
+  IsDefined,
+  IsAlphanumeric,
+  IsAlpha,
+  IsNumberString,
+  type RuleOptions,
+  type UUIDVersion,
+} from './rules/common';
+
+// 验证规则 - 条件和转换
+export {
+  ValidateIf,
+  Transform,
+  type ConditionalRuleOptions,
+} from './rules/conditional';
+
+// 自定义验证器
+export {
+  createCustomValidator,
+  createSimpleValidator,
+  createRegexValidator,
+  // 内置扩展验证器
+  IsPhoneNumber,
+  IsIdCard,
+  IsIPv4,
+  IsPort,
+  IsPostalCode,
+  IsCreditCard,
+  IsHexColor,
+  IsMacAddress,
+  IsSemVer,
+  IsDivisibleBy,
+  IsBetween,
+  Contains,
+  NotContains,
+  type CustomValidatorOptions,
+} from './custom-validator';
+
+// 类级别验证
+export {
+  ValidateClass,
+  Property,
+  NestedProperty,
+  ArrayNestedProperty,
+  validateObject,
+  validateObjectSync,
+  getClassValidationMetadata,
+  isValidateClass,
+} from './class-validator';
+
 

package/src/validation/rules/array.ts

@@ -0,0 +1,118 @@
+import type { ValidationRuleDefinition } from '../types';
+
+export interface ArrayRuleOptions {
+  message?: string;
+}
+
+/**
+ * 验证值是否为数组
+ */
+export function IsArray(options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isArray',
+    message: options.message ?? '必须是数组',
+    validate: (value) => Array.isArray(value),
+  };
+}
+
+/**
+ * 验证数组最小长度
+ */
+export function ArrayMinSize(min: number, options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayMinSize',
+    message: options.message ?? `数组长度不能小于 ${min}`,
+    validate: (value) => Array.isArray(value) && value.length >= min,
+  };
+}
+
+/**
+ * 验证数组最大长度
+ */
+export function ArrayMaxSize(max: number, options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayMaxSize',
+    message: options.message ?? `数组长度不能大于 ${max}`,
+    validate: (value) => Array.isArray(value) && value.length <= max,
+  };
+}
+
+/**
+ * 验证数组元素是否唯一
+ */
+export function ArrayUnique(options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayUnique',
+    message: options.message ?? '数组元素必须唯一',
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      const seen = new Set();
+      for (const item of value) {
+        // 对于对象，使用 JSON.stringify 进行比较
+        const key = typeof item === 'object' ? JSON.stringify(item) : item;
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+      }
+      return true;
+    },
+  };
+}
+
+/**
+ * 验证数组是否包含指定的值
+ */
+export function ArrayContains(values: unknown[], options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayContains',
+    message: options.message ?? `数组必须包含 ${values.join(', ')}`,
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      return values.every((v) => {
+        if (typeof v === 'object') {
+          const vStr = JSON.stringify(v);
+          return value.some((item) => JSON.stringify(item) === vStr);
+        }
+        return value.includes(v);
+      });
+    },
+  };
+}
+
+/**
+ * 验证数组是否不包含指定的值
+ */
+export function ArrayNotContains(values: unknown[], options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayNotContains',
+    message: options.message ?? `数组不能包含 ${values.join(', ')}`,
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      return values.every((v) => {
+        if (typeof v === 'object') {
+          const vStr = JSON.stringify(v);
+          return !value.some((item) => JSON.stringify(item) === vStr);
+        }
+        return !value.includes(v);
+      });
+    },
+  };
+}
+
+/**
+ * 验证数组是否为非空数组
+ */
+export function ArrayNotEmpty(options: ArrayRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'arrayNotEmpty',
+    message: options.message ?? '数组不能为空',
+    validate: (value) => Array.isArray(value) && value.length > 0,
+  };
+}

package/src/validation/rules/common.ts

@@ -0,0 +1,286 @@
+import type { ValidationRuleDefinition } from '../types';
+
+export interface RuleOptions {
+  message?: string;
+}
+
+/**
+ * 验证值是否为布尔值
+ */
+export function IsBoolean(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isBoolean',
+    message: options.message ?? '必须是布尔值',
+    validate: (value) => typeof value === 'boolean',
+  };
+}
+
+/**
+ * 验证值是否为整数
+ */
+export function IsInt(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isInt',
+    message: options.message ?? '必须是整数',
+    validate: (value) => typeof value === 'number' && Number.isInteger(value),
+  };
+}
+
+/**
+ * 验证值是否为正数
+ */
+export function IsPositive(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isPositive',
+    message: options.message ?? '必须是正数',
+    validate: (value) => typeof value === 'number' && value > 0,
+  };
+}
+
+/**
+ * 验证值是否为负数
+ */
+export function IsNegative(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNegative',
+    message: options.message ?? '必须是负数',
+    validate: (value) => typeof value === 'number' && value < 0,
+  };
+}
+
+/**
+ * 验证数字最小值
+ */
+export function Min(min: number, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'min',
+    message: options.message ?? `不能小于 ${min}`,
+    validate: (value) => typeof value === 'number' && value >= min,
+  };
+}
+
+/**
+ * 验证数字最大值
+ */
+export function Max(max: number, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'max',
+    message: options.message ?? `不能大于 ${max}`,
+    validate: (value) => typeof value === 'number' && value <= max,
+  };
+}
+
+/**
+ * 验证值是否为日期
+ */
+export function IsDate(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isDate',
+    message: options.message ?? '必须是有效的日期',
+    validate: (value) => {
+      if (value instanceof Date) {
+        return !Number.isNaN(value.getTime());
+      }
+      if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        return !Number.isNaN(date.getTime());
+      }
+      return false;
+    },
+  };
+}
+
+export type UUIDVersion = '3' | '4' | '5' | 'all';
+
+const UUID_PATTERNS: Record<UUIDVersion, RegExp> = {
+  '3': /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  '4': /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  '5': /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  'all': /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+};
+
+/**
+ * 验证值是否为 UUID
+ */
+export function IsUUID(version: UUIDVersion = 'all', options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isUUID',
+    message: options.message ?? `必须是有效的 UUID${version !== 'all' ? ` (v${version})` : ''}`,
+    validate: (value) => typeof value === 'string' && UUID_PATTERNS[version].test(value),
+  };
+}
+
+/**
+ * 验证字符串长度
+ */
+export function Length(min: number, max?: number, options: RuleOptions = {}): ValidationRuleDefinition {
+  const maxMsg = max !== undefined ? ` 且不能大于 ${max}` : '';
+  return {
+    name: 'length',
+    message: options.message ?? `长度不能小于 ${min}${maxMsg}`,
+    validate: (value) => {
+      if (typeof value !== 'string') {
+        return false;
+      }
+      if (value.length < min) {
+        return false;
+      }
+      if (max !== undefined && value.length > max) {
+        return false;
+      }
+      return true;
+    },
+  };
+}
+
+/**
+ * 验证字符串最大长度
+ */
+export function MaxLength(max: number, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'maxLength',
+    message: options.message ?? `长度不能大于 ${max}`,
+    validate: (value) => typeof value === 'string' && value.length <= max,
+  };
+}
+
+/**
+ * 验证值是否匹配正则表达式
+ */
+export function Matches(pattern: RegExp, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'matches',
+    message: options.message ?? `必须匹配格式 ${pattern.toString()}`,
+    validate: (value) => typeof value === 'string' && pattern.test(value),
+  };
+}
+
+/**
+ * 验证值是否在指定列表中
+ */
+export function IsIn(values: unknown[], options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isIn',
+    message: options.message ?? `必须是以下值之一: ${values.join(', ')}`,
+    validate: (value) => values.includes(value),
+  };
+}
+
+/**
+ * 验证值是否不在指定列表中
+ */
+export function IsNotIn(values: unknown[], options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNotIn',
+    message: options.message ?? `不能是以下值之一: ${values.join(', ')}`,
+    validate: (value) => !values.includes(value),
+  };
+}
+
+/**
+ * 验证值是否为 URL
+ */
+export function IsUrl(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isUrl',
+    message: options.message ?? '必须是有效的 URL',
+    validate: (value) => {
+      if (typeof value !== 'string') {
+        return false;
+      }
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+}
+
+/**
+ * 验证值是否为 JSON 字符串
+ */
+export function IsJSON(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isJSON',
+    message: options.message ?? '必须是有效的 JSON 字符串',
+    validate: (value) => {
+      if (typeof value !== 'string') {
+        return false;
+      }
+      try {
+        JSON.parse(value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+}
+
+/**
+ * 验证值是否相等
+ */
+export function Equals(comparison: unknown, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'equals',
+    message: options.message ?? `必须等于 ${comparison}`,
+    validate: (value) => value === comparison,
+  };
+}
+
+/**
+ * 验证值是否不相等
+ */
+export function NotEquals(comparison: unknown, options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'notEquals',
+    message: options.message ?? `不能等于 ${comparison}`,
+    validate: (value) => value !== comparison,
+  };
+}
+
+/**
+ * 验证是否为 null 或 undefined
+ */
+export function IsDefined(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isDefined',
+    message: options.message ?? '必须定义',
+    validate: (value) => value !== null && value !== undefined,
+  };
+}
+
+/**
+ * 验证字符串是否只包含字母数字字符
+ */
+export function IsAlphanumeric(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isAlphanumeric',
+    message: options.message ?? '只能包含字母和数字',
+    validate: (value) => typeof value === 'string' && /^[a-zA-Z0-9]+$/.test(value),
+  };
+}
+
+/**
+ * 验证字符串是否只包含字母
+ */
+export function IsAlpha(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isAlpha',
+    message: options.message ?? '只能包含字母',
+    validate: (value) => typeof value === 'string' && /^[a-zA-Z]+$/.test(value),
+  };
+}
+
+/**
+ * 验证字符串是否只包含数字
+ */
+export function IsNumberString(options: RuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNumberString',
+    message: options.message ?? '只能包含数字',
+    validate: (value) => typeof value === 'string' && /^[0-9]+$/.test(value),
+  };
+}

package/src/validation/rules/conditional.ts

@@ -0,0 +1,52 @@
+import type { ValidationRuleDefinition } from '../types';
+
+export interface ConditionalRuleOptions {
+  message?: string;
+}
+
+/**
+ * 条件验证装饰器
+ * 只有当条件函数返回 true 时才执行后续验证
+ *
+ * @example
+ * class UpdateUserDto {
+ *   @Validate(ValidateIf((value, obj) => obj.type === 'premium'), IsEmail())
+ *   email?: string;
+ * }
+ */
+export function ValidateIf(
+  condition: (value: unknown, obj?: unknown) => boolean,
+  options: ConditionalRuleOptions = {},
+): ValidationRuleDefinition {
+  return {
+    name: 'validateIf',
+    message: options.message ?? '',
+    condition,
+    validate: () => true, // 条件验证本身总是通过，由 condition 控制是否执行后续规则
+  };
+}
+
+/**
+ * 转换装饰器
+ * 在验证前转换值
+ *
+ * @example
+ * class CreateUserDto {
+ *   @Validate(Transform((value) => value?.trim()), IsString())
+ *   name: string;
+ *
+ *   @Validate(Transform((value) => Number(value)), IsInt(), Min(0))
+ *   age: number;
+ * }
+ */
+export function Transform(
+  transformFn: (value: unknown) => unknown,
+  options: ConditionalRuleOptions = {},
+): ValidationRuleDefinition {
+  return {
+    name: 'transform',
+    message: options.message ?? '',
+    transform: transformFn,
+    validate: () => true, // Transform 本身不验证，只转换
+  };
+}

package/src/validation/rules/index.ts

@@ -0,0 +1,51 @@
+export {
+  IsObject,
+  IsNotEmpty,
+  IsNotEmptyObject,
+  ValidateNested,
+  type ObjectRuleOptions,
+  type ValidateNestedOptions,
+} from './object';
+
+export {
+  IsArray,
+  ArrayMinSize,
+  ArrayMaxSize,
+  ArrayUnique,
+  ArrayContains,
+  ArrayNotContains,
+  ArrayNotEmpty,
+  type ArrayRuleOptions,
+} from './array';
+
+export {
+  IsBoolean,
+  IsInt,
+  IsPositive,
+  IsNegative,
+  Min,
+  Max,
+  IsDate,
+  IsUUID,
+  Length,
+  MaxLength,
+  Matches,
+  IsIn,
+  IsNotIn,
+  IsUrl,
+  IsJSON,
+  Equals,
+  NotEquals,
+  IsDefined,
+  IsAlphanumeric,
+  IsAlpha,
+  IsNumberString,
+  type RuleOptions,
+  type UUIDVersion,
+} from './common';
+
+export {
+  ValidateIf,
+  Transform,
+  type ConditionalRuleOptions,
+} from './conditional';

package/src/validation/rules/object.ts

@@ -0,0 +1,86 @@
+import type { ValidationRuleDefinition } from '../types';
+
+export interface ObjectRuleOptions {
+  message?: string;
+}
+
+/**
+ * 验证值是否为对象
+ */
+export function IsObject(options: ObjectRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isObject',
+    message: options.message ?? '必须是对象',
+    validate: (value) => typeof value === 'object' && value !== null && !Array.isArray(value),
+  };
+}
+
+/**
+ * 验证值是否为非空（不是 null、undefined、空字符串、空数组、空对象）
+ */
+export function IsNotEmpty(options: ObjectRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNotEmpty',
+    message: options.message ?? '不能为空',
+    validate: (value) => {
+      if (value === null || value === undefined) {
+        return false;
+      }
+      if (typeof value === 'string') {
+        return value.trim().length > 0;
+      }
+      if (Array.isArray(value)) {
+        return value.length > 0;
+      }
+      if (typeof value === 'object') {
+        return Object.keys(value).length > 0;
+      }
+      return true;
+    },
+  };
+}
+
+/**
+ * 验证值是否为非空对象（对象且至少有一个属性）
+ */
+export function IsNotEmptyObject(options: ObjectRuleOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNotEmptyObject',
+    message: options.message ?? '必须是非空对象',
+    validate: (value) => {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+      }
+      return Object.keys(value).length > 0;
+    },
+  };
+}
+
+export interface ValidateNestedOptions {
+  message?: string;
+  /**
+   * 是否对数组每个元素执行验证
+   * @default false
+   */
+  each?: boolean;
+}
+
+/**
+ * 嵌套对象验证装饰器
+ * 用于标记属性需要嵌套验证
+ */
+export function ValidateNested(options: ValidateNestedOptions = {}): ValidationRuleDefinition {
+  return {
+    name: 'validateNested',
+    message: options.message ?? '嵌套对象验证失败',
+    nested: true,
+    each: options.each ?? false,
+    validate: (value) => {
+      // 基础检查：必须是对象或数组
+      if (options.each) {
+        return Array.isArray(value);
+      }
+      return typeof value === 'object' && value !== null && !Array.isArray(value);
+    },
+  };
+}