@fo-rjsf/validator-ajv6
Version:
The ajv-6 based validator for @rjsf/core
172 lines (167 loc) • 6.78 kB
JavaScript
// src/validator.ts
import {
createErrorHandler,
getDefaultFormState,
ROOT_SCHEMA_PREFIX,
toErrorList,
toErrorSchema,
unwrapErrorHandler,
validationDataMerge,
withIdRefPrefix
} from "@rjsf/utils";
// src/createAjvInstance.ts
import Ajv from "ajv";
import isObject from "lodash/isObject";
var AJV_CONFIG = {
errorDataPath: "property",
allErrors: true,
multipleOfPrecision: 8,
schemaId: "auto",
unknownFormats: "ignore"
};
var COLOR_FORMAT_REGEX = /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/;
var DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}) {
const ajv = new Ajv({ ...AJV_CONFIG, ...ajvOptionsOverrides });
ajv.addFormat("data-url", DATA_URL_FORMAT_REGEX);
ajv.addFormat("color", COLOR_FORMAT_REGEX);
if (Array.isArray(additionalMetaSchemas)) {
ajv.addMetaSchema(additionalMetaSchemas);
}
if (isObject(customFormats)) {
Object.keys(customFormats).forEach((formatName) => {
ajv.addFormat(formatName, customFormats[formatName]);
});
}
return ajv;
}
// src/validator.ts
var AJV6Validator = class {
/** 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}`;
return {
name: keyword,
property,
message,
params,
// specific to ajv
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 = void 0;
try {
this.ajv.validate(schema, formData);
} catch (err) {
validationError = err;
}
const errors = this.ajv.errors || void 0;
this.ajv.errors = null;
return { 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 };
}
const newFormData = getDefaultFormState(this, schema, formData, rootSchema, true);
const errorHandler = customValidate(newFormData, createErrorHandler(newFormData), uiSchema);
const userErrorSchema = unwrapErrorHandler(errorHandler);
return validationDataMerge({ errors, errorSchema }, userErrorSchema);
}
/** 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 {
const result = this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX).validate(withIdRefPrefix(schema), formData);
return result;
} catch (e) {
return false;
} finally {
this.ajv.removeSchema(ROOT_SCHEMA_PREFIX);
}
}
};
// src/customizeValidator.ts
function customizeValidator(options = {}) {
return new AJV6Validator(options);
}
// src/index.ts
var src_default = customizeValidator();
export {
customizeValidator,
src_default as default
};
//# sourceMappingURL=validator-ajv6.esm.js.map