async-validator

To validate deep structures, use the fields property within an object or array type rule.

• For Objects: Assign a fields object containing rules for the nested properties.
• For Arrays: Assign a fields object where keys are indices (e.g., '0', '1') to validate specific elements.
• defaultField: For array or object types, you can use defaultField to apply the same rule to all elements/values in the container. This is expanded to fields internally.

const descriptor = {
  address: {
    type: 'object',
    required: true,
    fields: {
      street: { type: 'string', required: true },
      city: { type: 'string', required: true },
    },
  },
  urls: {
    type: 'array',
    required: true,
    defaultField: { type: 'url' },
  },
};

Install the async-validator package using npm to enable asynchronous form validation in your project.

npm i async-validator

Use the transform function in a rule to sanitize or coerce data before the validation rules are applied. The transformed value is what is passed to subsequent validators and returned in the validation result.

Note: The transform function should return the transformed value.

const descriptor = {
  name: {
    type: 'string',
    required: true,
    pattern: /^[a-z]+$/,
    transform(value) {
      return value.trim();
    },
  },
};

const validator = new Schema(descriptor);
const source = { name: ' user  ' };

// Validation passes because 'user' is trimmed before pattern check
validator.validate(source).then((data) => {
  console.log(data.name); // 'user'
});

You can customize error messages at different levels:

1. Per Rule: Assign a message property directly to a rule. { name: { type: 'string', required: true, message: 'Name is required' } }
2. Global/Schema Level: Use validator.messages(customMessages) to deep merge custom messages with default ones. This is useful for i18n.
3. Inside Custom Validators: Access options.messages within a validator function to retrieve custom messages defined in the schema.

import Schema from 'async-validator';

// Global message override
const cn = { required: '%s 必填' };
const descriptor = { name: { type: 'string', required: true } };
const validator = new Schema(descriptor);
validator.messages(cn);

When calling validate, you can pass an options object to control execution flow:

• suppressWarning (Boolean): Whether to suppress internal warnings about invalid values.
• first (Boolean): If true, the callback is invoked as soon as the first validation rule generates an error. No further rules are processed. Useful for expensive asynchronous checks (e.g., database queries).
• firstFields (Boolean|String[]): If true, the callback is invoked when the first rule of any field fails. If an array of strings is provided, it triggers when the first rule of the specified fields fails. No more rules for those specific fields are processed.

To suppress global warnings emitted by async-validator, you can either override the Schema.warning method with an empty function or set the ASYNC_VALIDATOR_NO_WARNING environment variable on globalThis to 1.

import Schema from 'async-validator';
Schema.warning = function(){};

To check if a value is strictly the boolean true, use the enum type rule and pass [true] as the enum option.

{
  type: 'enum',
  enum: [true],
  message: '',
}

The validate method is used to validate a source object against a schema descriptor. It can be used with a callback or as a Promise.

Arguments:

• source (required): The object to validate.
• options (optional): An object describing processing options.
• callback (optional): A function invoked when validation completes.

Return Values:

• Promise:
  • Resolves (.then()) if validation passes.
  • Rejects (.catch({ errors, fields })) if validation fails. errors is an array of all errors; fields is an object keyed by field name containing an array of errors per field.
• Callback: Invoked with (errors, fields).

You can define custom validation logic using validator or asyncValidator within your schema descriptor.

validator (Synchronous/Simple):

• Can return false, an Error, an Error array, or simply call the callback.
• Signature: function(rule, value, callback, source, options)

asyncValidator (Asynchronous):

• Use this for operations like AJAX calls or database lookups.
• You can either use the callback pattern or return a Promise.

The type property in a rule defines the validation logic. Supported types include:

• string: Default type.
• number, integer, float: Numeric validations.
• boolean: Must be a boolean.
• method: Must be a function.
• regexp: Must be a RegExp instance or a valid regex string.
• array: Must be an array.
• object: Must be an object (not an array).
• enum: Value must exist in the provided enum array.
• date: Must be a valid Date.
• url, hex, email: Format-specific validations.
• any: Accepts any type.

Standard rule properties for common validation tasks:

• required (Boolean): The field must exist on the source object.
• pattern (RegExp|String): The value must match this regular expression.
• min / max: Defines a range. For string/array, it checks length. For number, it checks the value.
• len (Number): Specifies an exact length for string/array, or an exact value for number. len takes precedence over min/max.
• whitespace (Boolean): If true (and type is string), a string consisting only of whitespace will be treated as an error.