@fluojs/validation 1.0.0-beta.1

package/dist/validation.js

@@ -0,0 +1,653 @@
+import validator from 'validator';
+import { getClassValidationRules, getDtoBindingSchema, getDtoValidationSchema } from '@fluojs/core/internal';
+import { DtoValidationError } from './errors.js';
+function resolveNestedDto(dto) {
+  if (typeof dto === 'function' && 'prototype' in dto && dto.prototype) {
+    return dto;
+  }
+  return dto();
+}
+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) => typeof value === 'string' && 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;
+  }
+  const instance = new target();
+  if (!isPlainObject(rawValue)) {
+    return instance;
+  }
+  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 {
+    code: rule.code ?? (rule.kind === 'validatorjs' ? rule.validator.toUpperCase() : handler.defaultCode),
+    message: rule.message ?? handler.describe(field, rule)
+  };
+}
+function runValidatorJs(rule, value) {
+  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 'latitude':
+      {
+        const number = Number(value);
+        return !Number.isNaN(number) && number >= -90 && number <= 90;
+      }
+    case 'longitude':
+      {
+        const number = Number(value);
+        return !Number.isNaN(number) && number >= -180 && number <= 180;
+      }
+    case 'latLong':
+      return validator.isLatLong(value);
+    default:
+      return false;
+  }
+}
+function buildIssue(fallback, field, source) {
+  return {
+    code: fallback.code,
+    field,
+    message: fallback.message,
+    source
+  };
+}
+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';
+}
+async function evaluateCustomRule(rule, value, dto, propertyKey, fieldPath, source, fallback) {
+  if (!rule.each) {
+    return normalizeResult(await rule.validate(value, {
+      dto,
+      propertyKey
+    }), fieldPath, rule.source ?? source, fallback);
+  }
+  const issues = [];
+  for (const [index, entry] of getRuleValues(value).entries()) {
+    const result = await rule.validate(entry, {
+      dto,
+      propertyKey
+    });
+    issues.push(...prefixIssues(normalizeResult(result, undefined, rule.source ?? source, fallback), `${fieldPath}[${String(index)}]`, source));
+  }
+  return issues;
+}
+function validateSingleRule(rule, value) {
+  if (rule.kind === 'custom' || rule.kind === 'nested') {
+    return true;
+  }
+  return runRulePredicate(rule, value);
+}
+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 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 trackedEntry = typeof entry === 'object' && entry !== null ? entry : undefined;
+    if (!(entry instanceof resolvedDto) && !isPlainObject(entry)) {
+      issues.push(buildIssue(describeValidator(rule, nestedPath), nestedPath, inheritedSource));
+      continue;
+    }
+    if (trackedEntry && context.active.has(trackedEntry)) {
+      issues.push(buildIssue(describeValidator(rule, nestedPath), nestedPath, inheritedSource));
+      continue;
+    }
+    const nestedDto = createNestedDtoInstance(resolvedDto, entry, context);
+    const shouldTrackEntry = trackedEntry && !(entry instanceof resolvedDto) ? enterTraversal(trackedEntry, context) : false;
+    try {
+      issues.push(...(await collectValidationIssuesInternal(resolvedDto, nestedDto, {
+        fieldPrefix: nestedPath,
+        inheritedSource
+      }, context)));
+    } finally {
+      if (trackedEntry && shouldTrackEntry) {
+        exitTraversal(trackedEntry, context);
+      }
+    }
+  }
+  return issues;
+}
+async function evaluateRule(rule, value, dto, propertyKey, fieldPath, source, context) {
+  const fallback = describeValidator(rule, fieldPath);
+  if (rule.kind === 'custom') {
+    return evaluateCustomRule(rule, value, dto, propertyKey, fieldPath, source, fallback);
+  }
+  if (rule.kind === 'nested') {
+    return validateNestedRule(rule, value, fieldPath, source, context);
+  }
+  if (rule.each) {
+    const issues = [];
+    for (const [index, entry] of getRuleValues(value).entries()) {
+      if (!validateSingleRule(rule, entry)) {
+        issues.push(buildIssue(fallback, `${fieldPath}[${String(index)}]`, source));
+      }
+    }
+    return issues;
+  }
+  if (!validateSingleRule(rule, value)) {
+    return [buildIssue(fallback, fieldPath, source)];
+  }
+  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 issues = [];
+  for (const rule of rules) {
+    if (rule.kind === 'validateIf' || rule.kind === 'optional') continue;
+    if (conditionallySkip) continue;
+    if (shouldSkipRuleForMissingValue(rule, value)) continue;
+    issues.push(...(await evaluateRule(rule, value, dto, propertyKey, fieldPath, source, context)));
+  }
+  return issues;
+}
+async function validateClassRule(rule, dto) {
+  return normalizeResult(await rule.validate(dto), undefined, undefined, {
+    code: rule.code ?? 'INVALID_DTO',
+    message: rule.message ?? 'DTO validation failed.'
+  });
+}
+async function shouldConditionallySkip(rules, dto, value) {
+  for (const rule of rules) {
+    if (rule.kind === 'validateIf' && !(await rule.validateIf(dto, value))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function collectValidationIssues(target, value) {
+  return collectValidationIssuesInternal(target, value, {}, {
+    active: new WeakSet()
+  });
+}
+async function collectValidationIssuesInternal(target, value, context, traversal) {
+  if (!enterTraversal(value, traversal)) {
+    return [];
+  }
+  try {
+    const metadata = getCachedDtoMetadata(target);
+    const issues = [];
+    for (const entry of metadata.dtoValidationSchema) {
+      const fieldValue = value[entry.propertyKey];
+      const source = metadata.bindingMap.get(entry.propertyKey)?.source ?? context.inheritedSource;
+      const fieldPath = context.fieldPrefix ? joinFieldPath(context.fieldPrefix, toFieldName(entry.propertyKey)) : toFieldName(entry.propertyKey);
+      issues.push(...(await applyPropertyRules(entry.rules, fieldValue, value, entry.propertyKey, fieldPath, source, traversal)));
+    }
+    for (const rule of metadata.classValidationRules) {
+      const classIssues = await validateClassRule(rule, value);
+      issues.push(...(context.fieldPrefix ? prefixIssues(classIssues, context.fieldPrefix, context.inheritedSource) : classIssues));
+    }
+    return issues;
+  } finally {
+    exitTraversal(value, traversal);
+  }
+}
+export class DefaultValidator {
+  async validate(value, target) {
+    const issues = await collectValidationIssues(target, value);
+    if (issues.length === 0) return;
+    throw new DtoValidationError('Validation failed.', issues);
+  }
+  async materialize(value, target) {
+    const instance = createNestedDtoInstance(target, value, {
+      active: new WeakSet()
+    });
+    const issues = await collectValidationIssues(target, instance);
+    if (issues.length > 0) {
+      throw new DtoValidationError('Validation failed.', issues);
+    }
+    return instance;
+  }
+}