@fluojs/validation 1.0.4 → 1.0.6

package/dist/validation.js

@@ -1,15 +1,7 @@
-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 { getCachedDtoMetadata, resolveNestedDto } from './internal/dto-metadata-cache.js';
+import { assignSafeOwnEnumerableProperties, getIterableValues, isPlainObject } from './internal/object-utils.js';
+import { getRuleHandler } from './internal/rule-handlers.js';
 function toFieldName(propertyKey) {
   return typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
 }
@@ -38,34 +30,6 @@ function normalizeResult(result, field, source, fallback) {
   }
   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}`;
@@ -93,246 +57,6 @@ function exitTraversal(value, context) {
   }
   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;
@@ -353,7 +77,7 @@ function createNestedDtoInstance(target, rawValue, context) {
       if (currentValue === undefined || currentValue === null) {
         continue;
       }
-      instance[nestedEntry.propertyKey] = nestedEntry.each ? transformNestedEachValue(currentValue, nestedEntry.target, context) : transformNestedValue(currentValue, nestedEntry.target, context);
+      instance[nestedEntry.propertyKey] = transformNestedCollectionValue(currentValue, nestedEntry.target, context);
     }
     return instance;
   } finally {
@@ -369,9 +93,6 @@ function materializeNestedDtoValue(target, rawValue, context) {
   }
   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;
@@ -382,7 +103,7 @@ function applyBindingValues(instance, rawValue, keys, bindingMap) {
 function transformNestedValue(value, target, context) {
   return value === undefined || value === null ? value : materializeNestedDtoValue(target, value, context);
 }
-function transformNestedEachValue(value, target, context) {
+function transformNestedCollectionValue(value, target, context) {
   if (Array.isArray(value)) {
     return value.map(item => transformNestedValue(item, target, context));
   }
@@ -401,93 +122,6 @@ 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,
@@ -541,12 +175,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));

package/package.json

@@ -9,7 +9,7 @@
     "decorators",
     "schema"
   ],
-  "version": "1.0.4",
+  "version": "1.0.6",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -42,7 +42,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "validator": "^13.15.26",
-    "@fluojs/core": "^1.0.3"
+    "@fluojs/core": "^1.1.0"
   },
   "devDependencies": {
     "@types/validator": "^13.15.10",