@dangao/bun-server 1.7.1 → 1.8.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);
+    },
+  };
+}

package/src/validation/types.ts

@@ -11,13 +11,41 @@ export interface ValidationRuleDefinition {
 
   /**
    * 校验函数
+   * @param value - 要验证的值
+   * @param obj - 完整对象（用于条件验证）
    */
-  validate: (value: unknown) => boolean;
+  validate: (value: unknown, obj?: unknown) => boolean;
 
   /**
    * 是否为可选字段
    */
   optional?: boolean;
+
+  /**
+   * 条件验证函数
+   * 返回 true 时执行验证，返回 false 时跳过
+   */
+  condition?: (value: unknown, obj?: unknown) => boolean;
+
+  /**
+   * 转换函数（在验证前执行）
+   */
+  transform?: (value: unknown) => unknown;
+
+  /**
+   * 是否为嵌套验证
+   */
+  nested?: boolean;
+
+  /**
+   * 嵌套验证的类型
+   */
+  nestedType?: new () => unknown;
+
+  /**
+   * 是否对数组每个元素执行嵌套验证
+   */
+  each?: boolean;
 }
 
 export interface ValidationMetadata {
@@ -32,4 +60,36 @@ export interface ValidationMetadata {
   rules: ValidationRuleDefinition[];
 }
 
+/**
+ * 类级别验证元数据
+ */
+export interface ClassValidationMetadata {
+  /**
+   * 属性名
+   */
+  property: string;
+
+  /**
+   * 规则列表
+   */
+  rules: ValidationRuleDefinition[];
+}
+
+/**
+ * 验证选项
+ */
+export interface ValidationOptions {
+  /**
+   * 是否在第一个错误时停止验证
+   * @default false
+   */
+  stopAtFirstError?: boolean;
+
+  /**
+   * 是否跳过缺失的属性
+   * @default false
+   */
+  skipMissingProperties?: boolean;
+}
+