@rjsf/validator-ajv6
Version:
The ajv-6 based validator for @rjsf/core
149 lines • 7.27 kB
JavaScript
import { createErrorHandler, deepEquals, getDefaultFormState, ROOT_SCHEMA_PREFIX, toErrorList, toErrorSchema, unwrapErrorHandler, validationDataMerge, withIdRefPrefix, } from '@rjsf/utils';
import createAjvInstance from './createAjvInstance.js';
/** `ValidatorType` implementation that uses the AJV 6 validation mechanism.
*
* @deprecated in favor of the `@rjsf/validator-ajv8
*/
export default class AJV6Validator {
/** Constructs an `AJV6Validator` instance using the `options`
*
* @param options - The `CustomValidatorOptionsType` options that are used to create the AJV instance
*/
constructor(options) {
const { additionalMetaSchemas, customFormats, ajvOptionsOverrides } = options;
this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides);
}
/** Converts an `errorSchema` into a list of `RJSFValidationErrors`
*
* @param errorSchema - The `ErrorSchema` instance to convert
* @param [fieldPath=[]] - The current field path, defaults to [] if not specified
* @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
* the next major release.
*/
toErrorList(errorSchema, fieldPath = []) {
return toErrorList(errorSchema, fieldPath);
}
/** Transforming the error output from ajv to format used by @rjsf/utils.
* At some point, components should be updated to support ajv.
*
* @param errors - The list of AJV errors to convert to `RJSFValidationErrors`
* @private
*/
transformRJSFValidationErrors(errors = []) {
return errors.map((e) => {
const { dataPath, keyword, message, params, schemaPath } = e;
const property = `${dataPath}`;
// put data in expected format
return {
name: keyword,
property,
message,
params,
stack: `${property} ${message}`.trim(),
schemaPath,
};
});
}
/** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
* by the playground. Returns the `errors` from the validation
*
* @param schema - The schema against which to validate the form data * @param schema
* @param formData - The form data to validate
*/
rawValidation(schema, formData) {
let validationError = undefined;
try {
this.ajv.validate(schema, formData);
}
catch (err) {
validationError = err;
}
const errors = this.ajv.errors || undefined;
// Clear errors to prevent persistent errors, see #1104
this.ajv.errors = null;
return { errors: errors, validationError };
}
/** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
* the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
* supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
* transform them in what ever way it chooses.
*
* @param formData - The form data to validate
* @param schema - The schema against which to validate the form data
* @param [customValidate] - An optional function that is used to perform custom validation
* @param [transformErrors] - An optional function that is used to transform errors after AJV validation
* @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
*/
validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
const rootSchema = schema;
const rawErrors = this.rawValidation(schema, formData);
const { validationError } = rawErrors;
let errors = this.transformRJSFValidationErrors(rawErrors.errors);
const noProperMetaSchema = validationError && validationError.message && validationError.message.includes('no schema with key or ref ');
if (noProperMetaSchema) {
errors = [...errors, { stack: validationError.message }];
}
if (typeof transformErrors === 'function') {
errors = transformErrors(errors, uiSchema);
}
let errorSchema = toErrorSchema(errors);
if (noProperMetaSchema) {
errorSchema = {
...errorSchema,
...{
$schema: {
__errors: [validationError.message],
},
},
};
}
if (typeof customValidate !== 'function') {
return { errors, errorSchema };
}
// Include form data with undefined values, which is required for custom validation.
const newFormData = getDefaultFormState(this, schema, formData, rootSchema, true);
const errorHandler = customValidate(newFormData, createErrorHandler(newFormData), uiSchema);
const userErrorSchema = unwrapErrorHandler(errorHandler);
return validationDataMerge({ errors, errorSchema }, userErrorSchema);
}
/**
* This function checks if a schema needs to be added and if the root schemas don't match it removes the old root schema from the ajv instance and adds the new one.
* @param rootSchema - The root schema used to provide $ref resolutions
*/
handleSchemaUpdate(rootSchema) {
var _a;
const rootSchemaId = ROOT_SCHEMA_PREFIX;
// add the rootSchema ROOT_SCHEMA_PREFIX as id.
// if schema validator instance doesn't exist, add it.
// else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
if (this.ajv.getSchema(ROOT_SCHEMA_PREFIX) === undefined) {
this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX);
}
else if (!deepEquals(rootSchema, (_a = this.ajv.getSchema(ROOT_SCHEMA_PREFIX)) === null || _a === void 0 ? void 0 : _a.schema)) {
this.ajv.removeSchema(rootSchemaId);
this.ajv.addSchema(rootSchema, rootSchemaId);
}
}
/** Validates data against a schema, returning true if the data is valid, or
* false otherwise. If the schema is invalid, then this function will return
* false.
*
* @param schema - The schema against which to validate the form data * @param schema
* @param formData- - The form data to validate
* @param rootSchema - The root schema used to provide $ref resolutions
*/
isValid(schema, formData, rootSchema) {
try {
this.handleSchemaUpdate(rootSchema);
// then rewrite the schema ref's to point to the rootSchema
// this accounts for the case where schema have references to models
// that lives in the rootSchema but not in the schema in question.
const result = this.ajv.validate(withIdRefPrefix(schema), formData);
return result;
}
catch (e) {
return false;
}
}
}
//# sourceMappingURL=validator.js.map