@fluojs/validation 1.0.5 → 2.0.0

package/dist/validation.js

@@ -1,399 +1,12 @@
-import validator from 'validator';
-import { getClassValidationRules, getDtoBindingSchema, getDtoValidationSchema } from '@fluojs/core/internal';
 import { DtoValidationError } from './errors.js';
-function isClassConstructor(dto) {
-  return typeof dto === 'function' && Function.prototype.toString.call(dto).startsWith('class ');
-}
-function resolveNestedDto(dto) {
-  if (isClassConstructor(dto)) {
-    return dto;
-  }
-  return dto();
-}
+import { assertValidRootValue, createNestedDtoInstance, enterTraversal, exitTraversal } from './internal/dto-materialization.js';
+import { getCachedDtoMetadata, resolveNestedDto } from './internal/dto-metadata-cache.js';
+import { getIterableValues, isPlainObject } from './internal/object-utils.js';
+import { getRuleHandler } from './internal/rule-handlers.js';
+import { buildIssue, joinFieldPath, normalizeResult, prefixIssues } from './internal/validation-issues.js';
 function toFieldName(propertyKey) {
   return typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
 }
-function normalizeIssue(issue, field, source) {
-  return {
-    code: issue.code,
-    field: issue.field ?? field,
-    message: issue.message,
-    source: issue.source ?? source
-  };
-}
-function normalizeResult(result, field, source, fallback) {
-  if (result === undefined || result === true) {
-    return [];
-  }
-  if (result === false) {
-    return [{
-      code: fallback.code,
-      field,
-      message: fallback.message,
-      source
-    }];
-  }
-  if (Array.isArray(result)) {
-    return result.map(issue => normalizeIssue(issue, field, source));
-  }
-  return [normalizeIssue(result, field, source)];
-}
-function getIterableValues(value) {
-  if (Array.isArray(value)) return value;
-  if (value instanceof Set) return Array.from(value.values());
-  if (value instanceof Map) return Array.from(value.values());
-  return undefined;
-}
-function isPlainObject(value) {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-function assignSafeOwnEnumerableProperties(target, source) {
-  for (const key of Reflect.ownKeys(source)) {
-    if (typeof key === 'string' && DANGEROUS_KEYS.has(key)) {
-      continue;
-    }
-    if (!Object.prototype.propertyIsEnumerable.call(source, key)) {
-      continue;
-    }
-    target[key] = source[key];
-  }
-}
-function isEmptyValue(value) {
-  return value === '' || value === null || value === undefined;
-}
-function joinFieldPath(parent, child) {
-  if (!child) return parent;
-  return child.startsWith('[') ? `${parent}${child}` : `${parent}.${child}`;
-}
-function prefixIssues(issues, fieldPrefix, source) {
-  return issues.map(issue => ({
-    ...issue,
-    field: joinFieldPath(fieldPrefix, issue.field),
-    source: issue.source ?? source
-  }));
-}
-function enterTraversal(value, context) {
-  if (!context || typeof value !== 'object' || value === null) {
-    return true;
-  }
-  if (context.active.has(value)) {
-    return false;
-  }
-  context.active.add(value);
-  return true;
-}
-function exitTraversal(value, context) {
-  if (!context || typeof value !== 'object' || value === null) {
-    return;
-  }
-  context.active.delete(value);
-}
-const dtoMetadataCache = new WeakMap();
-function collectNestedDtoTransforms(dtoValidationSchema) {
-  const nestedEntries = [];
-  for (const entry of dtoValidationSchema) {
-    const nestedRule = entry.rules.find(rule => rule.kind === 'nested');
-    if (!nestedRule) {
-      continue;
-    }
-    nestedEntries.push({
-      each: nestedRule.each === true,
-      propertyKey: entry.propertyKey,
-      target: resolveNestedDto(nestedRule.dto)
-    });
-  }
-  return nestedEntries;
-}
-function getCachedDtoMetadata(target) {
-  const cached = dtoMetadataCache.get(target);
-  if (cached) {
-    return cached;
-  }
-  const bindingMap = getDtoBindingMap(target);
-  const dtoValidationSchema = getDtoValidationSchema(target);
-  const classValidationRules = getClassValidationRules(target);
-  const mergedPropertyKeys = new Set([...bindingMap.keys(), ...dtoValidationSchema.map(entry => entry.propertyKey)]);
-  const nestedDtoTransforms = collectNestedDtoTransforms(dtoValidationSchema);
-  const next = {
-    bindingMap,
-    classValidationRules,
-    dtoValidationSchema,
-    mergedPropertyKeys,
-    nestedDtoTransforms
-  };
-  dtoMetadataCache.set(target, next);
-  return next;
-}
-function getRuleHandler(rule) {
-  return RULE_HANDLERS[rule.kind];
-}
-const RULE_HANDLERS = {
-  validateIf: {
-    defaultCode: 'VALIDATE_IF',
-    describe: field => `${field} is conditionally invalid.`,
-    validate: () => true
-  },
-  defined: {
-    defaultCode: 'REQUIRED',
-    describe: field => `${field} is required.`,
-    validate: (_rule, value) => value !== undefined && value !== null
-  },
-  optional: {
-    defaultCode: 'OPTIONAL',
-    describe: field => `${field} is optional.`,
-    validate: () => true
-  },
-  equals: {
-    defaultCode: 'EQUALS',
-    describe: (field, rule) => `${field} must equal ${String(rule.value)}.`,
-    validate: (rule, value) => value === rule.value
-  },
-  notEquals: {
-    defaultCode: 'NOT_EQUALS',
-    describe: (field, rule) => `${field} must not equal ${String(rule.value)}.`,
-    validate: (rule, value) => value !== rule.value
-  },
-  empty: {
-    defaultCode: 'EMPTY',
-    describe: field => `${field} must be empty.`,
-    validate: (_rule, value) => isEmptyValue(value)
-  },
-  notEmpty: {
-    defaultCode: 'NOT_EMPTY',
-    describe: field => `${field} should not be empty.`,
-    validate: (_rule, value) => !isEmptyValue(value)
-  },
-  in: {
-    defaultCode: 'IN',
-    describe: field => `${field} must be one of the allowed values.`,
-    validate: (rule, value) => rule.values.includes(value)
-  },
-  notIn: {
-    defaultCode: 'NOT_IN',
-    describe: field => `${field} contains a forbidden value.`,
-    validate: (rule, value) => !rule.values.includes(value)
-  },
-  string: {
-    defaultCode: 'INVALID_STRING',
-    describe: field => `${field} must be a string.`,
-    validate: (_rule, value) => typeof value === 'string'
-  },
-  number: {
-    defaultCode: 'INVALID_NUMBER',
-    describe: field => `${field} must be a number.`,
-    validate: (rule, value) => typeof value === 'number' && (rule.allowNaN || !Number.isNaN(value))
-  },
-  boolean: {
-    defaultCode: 'INVALID_BOOLEAN',
-    describe: field => `${field} must be a boolean.`,
-    validate: (_rule, value) => typeof value === 'boolean'
-  },
-  date: {
-    defaultCode: 'INVALID_DATE',
-    describe: field => `${field} must be a Date instance.`,
-    validate: (_rule, value) => value instanceof Date && !Number.isNaN(value.getTime())
-  },
-  array: {
-    defaultCode: 'INVALID_ARRAY',
-    describe: field => `${field} must be an array.`,
-    validate: (_rule, value) => Array.isArray(value)
-  },
-  object: {
-    defaultCode: 'INVALID_OBJECT',
-    describe: field => `${field} must be an object.`,
-    validate: (_rule, value) => isPlainObject(value)
-  },
-  enum: {
-    defaultCode: 'INVALID_ENUM',
-    describe: field => `${field} must be a supported enum value.`,
-    validate: (rule, value) => rule.values.includes(value)
-  },
-  int: {
-    defaultCode: 'INVALID_INT',
-    describe: field => `${field} must be an integer.`,
-    validate: (_rule, value) => typeof value === 'number' && Number.isInteger(value)
-  },
-  divisibleBy: {
-    defaultCode: 'DIVISIBLE_BY',
-    describe: (field, rule) => `${field} must be divisible by ${String(rule.value)}.`,
-    validate: (rule, value) => typeof value === 'number' && !Number.isNaN(value) && value % rule.value === 0
-  },
-  positive: {
-    defaultCode: 'POSITIVE',
-    describe: field => `${field} must be positive.`,
-    validate: (_rule, value) => typeof value === 'number' && value > 0
-  },
-  negative: {
-    defaultCode: 'NEGATIVE',
-    describe: field => `${field} must be negative.`,
-    validate: (_rule, value) => typeof value === 'number' && value < 0
-  },
-  min: {
-    defaultCode: 'MIN',
-    describe: (field, rule) => `${field} must be greater than or equal to ${String(rule.value)}.`,
-    validate: (rule, value) => typeof value === 'number' && !Number.isNaN(value) && value >= rule.value
-  },
-  max: {
-    defaultCode: 'MAX',
-    describe: (field, rule) => `${field} must be less than or equal to ${String(rule.value)}.`,
-    validate: (rule, value) => typeof value === 'number' && !Number.isNaN(value) && value <= rule.value
-  },
-  minDate: {
-    defaultCode: 'MIN_DATE',
-    describe: (field, rule) => `${field} must be on or after ${rule.value.toISOString()}.`,
-    validate: (rule, value) => value instanceof Date && !Number.isNaN(value.getTime()) && value.getTime() >= rule.value.getTime()
-  },
-  maxDate: {
-    defaultCode: 'MAX_DATE',
-    describe: (field, rule) => `${field} must be on or before ${rule.value.toISOString()}.`,
-    validate: (rule, value) => value instanceof Date && !Number.isNaN(value.getTime()) && value.getTime() <= rule.value.getTime()
-  },
-  contains: {
-    defaultCode: 'CONTAINS',
-    describe: (field, rule) => `${field} must contain ${rule.value}.`,
-    validate: (rule, value) => typeof value === 'string' && value.includes(rule.value)
-  },
-  notContains: {
-    defaultCode: 'NOT_CONTAINS',
-    describe: (field, rule) => `${field} must not contain ${rule.value}.`,
-    validate: (rule, value) => typeof value === 'string' && !value.includes(rule.value)
-  },
-  length: {
-    defaultCode: 'LENGTH',
-    describe: field => `${field} must have a valid length.`,
-    validate: (rule, value) => typeof value === 'string' && value.length >= rule.min && (rule.max === undefined || value.length <= rule.max)
-  },
-  minLength: {
-    defaultCode: 'MIN_LENGTH',
-    describe: (field, rule) => `${field} must have length at least ${String(rule.value)}.`,
-    validate: (rule, value) => typeof value === 'string' && value.length >= rule.value
-  },
-  maxLength: {
-    defaultCode: 'MAX_LENGTH',
-    describe: (field, rule) => `${field} must have length at most ${String(rule.value)}.`,
-    validate: (rule, value) => typeof value === 'string' && value.length <= rule.value
-  },
-  nested: {
-    defaultCode: 'INVALID_NESTED',
-    describe: field => `${field} contains invalid nested data.`,
-    validate: () => true
-  },
-  validatorjs: {
-    defaultCode: 'INVALID_FIELD',
-    describe: field => `${field} is invalid.`,
-    validate: (rule, value) => runValidatorJs(rule, value)
-  },
-  arrayContains: {
-    defaultCode: 'ARRAY_CONTAINS',
-    describe: field => `${field} must contain the required values.`,
-    validate: (rule, value) => Array.isArray(value) && rule.values.every(expected => value.includes(expected))
-  },
-  arrayNotContains: {
-    defaultCode: 'ARRAY_NOT_CONTAINS',
-    describe: field => `${field} contains forbidden values.`,
-    validate: (rule, value) => Array.isArray(value) && rule.values.every(expected => !value.includes(expected))
-  },
-  arrayNotEmpty: {
-    defaultCode: 'ARRAY_NOT_EMPTY',
-    describe: field => `${field} must not be an empty array.`,
-    validate: (_rule, value) => Array.isArray(value) && value.length > 0
-  },
-  arrayMinSize: {
-    defaultCode: 'ARRAY_MIN_SIZE',
-    describe: (field, rule) => `${field} must contain at least ${String(rule.value)} items.`,
-    validate: (rule, value) => Array.isArray(value) && value.length >= rule.value
-  },
-  arrayMaxSize: {
-    defaultCode: 'ARRAY_MAX_SIZE',
-    describe: (field, rule) => `${field} must contain at most ${String(rule.value)} items.`,
-    validate: (rule, value) => Array.isArray(value) && value.length <= rule.value
-  },
-  arrayUnique: {
-    defaultCode: 'ARRAY_UNIQUE',
-    describe: field => `${field} must contain unique values.`,
-    validate: (rule, value) => {
-      if (!Array.isArray(value)) return false;
-      const seen = new Set();
-      for (const entry of value) {
-        const key = rule.selector ? rule.selector(entry) : entry;
-        if (seen.has(key)) return false;
-        seen.add(key);
-      }
-      return true;
-    }
-  },
-  custom: {
-    defaultCode: 'INVALID_FIELD',
-    describe: field => `${field} is invalid.`,
-    validate: () => true
-  }
-};
-function createNestedDtoInstance(target, rawValue, context) {
-  if (rawValue instanceof target) {
-    return rawValue;
-  }
-  if (!isPlainObject(rawValue)) {
-    return rawValue;
-  }
-  const instance = new target();
-  if (!enterTraversal(rawValue, context)) {
-    return rawValue;
-  }
-  try {
-    assignSafeOwnEnumerableProperties(instance, rawValue);
-    const metadata = getCachedDtoMetadata(target);
-    applyBindingValues(instance, rawValue, metadata.mergedPropertyKeys, metadata.bindingMap);
-    for (const nestedEntry of metadata.nestedDtoTransforms) {
-      const currentValue = instance[nestedEntry.propertyKey];
-      if (currentValue === undefined || currentValue === null) {
-        continue;
-      }
-      instance[nestedEntry.propertyKey] = nestedEntry.each ? transformNestedEachValue(currentValue, nestedEntry.target, context) : transformNestedValue(currentValue, nestedEntry.target, context);
-    }
-    return instance;
-  } finally {
-    exitTraversal(rawValue, context);
-  }
-}
-function materializeNestedDtoValue(target, rawValue, context) {
-  if (rawValue instanceof target) {
-    return rawValue;
-  }
-  if (!isPlainObject(rawValue)) {
-    return rawValue;
-  }
-  return createNestedDtoInstance(target, rawValue, context);
-}
-function getDtoBindingMap(target) {
-  return new Map(getDtoBindingSchema(target).map(entry => [entry.propertyKey, entry.metadata]));
-}
-function applyBindingValues(instance, rawValue, keys, bindingMap) {
-  for (const propertyKey of keys) {
-    const sourceKey = bindingMap.get(propertyKey)?.key;
-    if (!sourceKey) continue;
-    instance[propertyKey] = rawValue[sourceKey];
-  }
-}
-function transformNestedValue(value, target, context) {
-  return value === undefined || value === null ? value : materializeNestedDtoValue(target, value, context);
-}
-function transformNestedEachValue(value, target, context) {
-  if (Array.isArray(value)) {
-    return value.map(item => transformNestedValue(item, target, context));
-  }
-  if (value instanceof Set) {
-    return new Set(Array.from(value.values(), item => transformNestedValue(item, target, context)));
-  }
-  if (value instanceof Map) {
-    return new Map(Array.from(value.entries(), ([key, item]) => [key, transformNestedValue(item, target, context)]));
-  }
-  return transformNestedValue(value, target, context);
-}
 function describeValidator(rule, field) {
   const handler = getRuleHandler(rule);
   return {
@@ -401,118 +14,11 @@ function describeValidator(rule, field) {
     message: rule.message ?? handler.describe(field, rule)
   };
 }
-function runValidatorJs(rule, value) {
-  if (rule.validator === 'latitude') {
-    return typeof value === 'number' && Number.isFinite(value) && value >= -90 && value <= 90;
-  }
-  if (rule.validator === 'longitude') {
-    return typeof value === 'number' && Number.isFinite(value) && value >= -180 && value <= 180;
-  }
-  if (typeof value !== 'string') {
-    return false;
-  }
-  switch (rule.validator) {
-    case 'alpha':
-      return validator.isAlpha(value);
-    case 'alphanumeric':
-      return validator.isAlphanumeric(value);
-    case 'ascii':
-      return validator.isAscii(value);
-    case 'base64':
-      return validator.isBase64(value);
-    case 'booleanString':
-      return validator.isBoolean(value);
-    case 'currency':
-      return validator.isCurrency(value, rule.args?.[0]);
-    case 'dataURI':
-      return validator.isDataURI(value);
-    case 'dateString':
-      return validator.isISO8601(value);
-    case 'decimal':
-      return validator.isDecimal(value);
-    case 'email':
-      return validator.isEmail(value, rule.args?.[0]);
-    case 'fqdn':
-      return validator.isFQDN(value, rule.args?.[0]);
-    case 'hexColor':
-      return validator.isHexColor(value);
-    case 'hexadecimal':
-      return validator.isHexadecimal(value);
-    case 'ip':
-      return validator.isIP(value, rule.args?.[0]);
-    case 'isbn':
-      return validator.isISBN(value, rule.args?.[0]);
-    case 'issn':
-      return validator.isISSN(value);
-    case 'json':
-      return validator.isJSON(value);
-    case 'jwt':
-      return validator.isJWT(value);
-    case 'locale':
-      return validator.isLocale(value);
-    case 'lowercase':
-      return validator.isLowercase(value);
-    case 'magnetURI':
-      return validator.isMagnetURI(value);
-    case 'matches':
-      return validator.matches(value, rule.args?.[0], rule.args?.[1]);
-    case 'mimeType':
-      return validator.isMimeType(value);
-    case 'mobilePhone':
-      return validator.isMobilePhone(value, rule.args?.[0]);
-    case 'mongoId':
-      return validator.isMongoId(value);
-    case 'numberString':
-      return validator.isNumeric(value);
-    case 'port':
-      return validator.isPort(value);
-    case 'postalCode':
-      return validator.isPostalCode(value, rule.args?.[0] ?? 'any');
-    case 'rgbColor':
-      return validator.isRgbColor(value, rule.args?.[0]);
-    case 'rfc3339':
-      return validator.isRFC3339(value);
-    case 'semVer':
-      return validator.isSemVer(value);
-    case 'uppercase':
-      return validator.isUppercase(value);
-    case 'url':
-      return validator.isURL(value, rule.args?.[0]);
-    case 'uuid':
-      return validator.isUUID(value, rule.args?.[0]);
-    case 'iso8601':
-      return validator.isISO8601(value);
-    case 'latLong':
-      return validator.isLatLong(value);
-    default:
-      return false;
-  }
-}
-function buildIssue(fallback, field, source) {
-  return {
-    code: fallback.code,
-    field,
-    message: fallback.message,
-    source
-  };
-}
-function buildInvalidRootIssue() {
-  return {
-    code: 'INVALID_DTO',
-    message: 'DTO root value must be a plain object.'
-  };
-}
-function assertValidRootValue(value, target) {
-  if (value instanceof target || isPlainObject(value)) {
-    return;
-  }
-  throw new DtoValidationError('Validation failed.', [buildInvalidRootIssue()]);
-}
 function getRuleValues(value) {
   return getIterableValues(value) ?? [value];
 }
 function shouldSkipRuleForMissingValue(rule, value) {
-  return (value === undefined || value === null) && rule.kind !== 'defined' && rule.kind !== 'notEmpty' && rule.kind !== 'empty';
+  return (value === undefined || value === null) && rule.kind !== 'defined' && rule.kind !== 'empty';
 }
 async function evaluateCustomRule(rule, value, dto, propertyKey, fieldPath, source, fallback) {
   if (!rule.each) {
@@ -541,12 +47,14 @@ function runRulePredicate(rule, value) {
   return getRuleHandler(rule).validate(rule, value);
 }
 async function validateNestedRule(rule, value, fieldPath, inheritedSource, context) {
-  const values = rule.each ? getIterableValues(value) ?? [value] : [value];
+  const collectionValues = getIterableValues(value);
+  const values = collectionValues ?? [value];
+  const useIndexedPath = rule.each === true || collectionValues !== undefined;
   const issues = [];
   const resolvedDto = resolveNestedDto(rule.dto);
   for (const [index, entry] of values.entries()) {
     if (entry === undefined || entry === null) continue;
-    const nestedPath = rule.each ? `${fieldPath}[${String(index)}]` : fieldPath;
+    const nestedPath = useIndexedPath ? `${fieldPath}[${String(index)}]` : fieldPath;
     const trackedEntry = typeof entry === 'object' && entry !== null ? entry : undefined;
     if (!(entry instanceof resolvedDto) && !isPlainObject(entry)) {
       issues.push(buildIssue(describeValidator(rule, nestedPath), nestedPath, inheritedSource));
@@ -556,7 +64,7 @@ async function validateNestedRule(rule, value, fieldPath, inheritedSource, conte
       issues.push(buildIssue(describeValidator(rule, nestedPath), nestedPath, inheritedSource));
       continue;
     }
-    const nestedDto = createNestedDtoInstance(resolvedDto, entry, context);
+    const nestedDto = createNestedDtoInstance(resolvedDto, entry, context, nestedPath);
     const shouldTrackEntry = trackedEntry && !(entry instanceof resolvedDto) ? enterTraversal(trackedEntry, context) : false;
     try {
       issues.push(...(await collectValidationIssuesInternal(resolvedDto, nestedDto, {
@@ -594,10 +102,10 @@ async function evaluateRule(rule, value, dto, propertyKey, fieldPath, source, co
   return [];
 }
 async function applyPropertyRules(rules, value, dto, propertyKey, fieldPath, source, context) {
-  const conditionallySkip = await shouldConditionallySkip(rules, dto, value);
   if (rules.some(rule => rule.kind === 'optional') && (value === undefined || value === null)) {
     return [];
   }
+  const conditionallySkip = await shouldConditionallySkip(rules, dto, value);
   const issues = [];
   for (const rule of rules) {
     if (rule.kind === 'validateIf' || rule.kind === 'optional') continue;
@@ -659,12 +167,19 @@ export class DefaultValidator {
     if (issues.length === 0) return;
     throw new DtoValidationError('Validation failed.', issues);
   }
-  async materialize(value, target) {
+  async materialize(value, target, options = {}) {
     assertValidRootValue(value, target);
-    const instance = createNestedDtoInstance(target, value, {
-      active: new WeakSet()
-    });
-    const issues = await collectValidationIssues(target, instance);
+    const traversal = {
+      active: new WeakSet(),
+      hydrateExistingInstances: true,
+      undeclaredProperties: options.undeclaredProperties ?? 'preserve',
+      materialized: new WeakMap(),
+      ...(options.undeclaredProperties === 'reject' ? {
+        declaredNestedKeys: new WeakMap()
+      } : {})
+    };
+    const instance = createNestedDtoInstance(target, value, traversal);
+    const issues = await collectValidationIssuesInternal(target, instance, {}, traversal);
     if (issues.length > 0) {
       throw new DtoValidationError('Validation failed.', issues);
     }

package/package.json

@@ -9,7 +9,7 @@
     "decorators",
     "schema"
   ],
-  "version": "1.0.5",
+  "version": "2.0.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
     "directory": "packages/validation"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0 <27"
   },
   "publishConfig": {
     "access": "public"
@@ -42,13 +42,13 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "validator": "^13.15.26",
-    "@fluojs/core": "^1.0.3"
+    "@fluojs/core": "^2.0.0"
   },
   "devDependencies": {
     "@types/validator": "^13.15.10",
     "arktype": "^2.2.0",
     "valibot": "^1.0.0",
-    "vitest": "^3.2.4",
+    "vitest": "^4.1.11",
     "zod": "^4.1.11"
   },
   "scripts": {