145 lines
5.6 KiB
JavaScript
145 lines
5.6 KiB
JavaScript
import copy from "../utils/copy";
|
|
export class Draft {
|
|
constructor(config, schema) {
|
|
/** cache for remote schemas */
|
|
this.remotes = {};
|
|
/** error creators by id */
|
|
this.errors = {};
|
|
/** map for valid keywords of a type */
|
|
this.typeKeywords = {};
|
|
/** keyword validators */
|
|
this.validateKeyword = {};
|
|
/** type validators */
|
|
this.validateType = {};
|
|
/** format validators */
|
|
this.validateFormat = {};
|
|
this.config = config;
|
|
this.typeKeywords = copy(config.typeKeywords);
|
|
this.validateKeyword = Object.assign({}, config.validateKeyword);
|
|
this.validateType = Object.assign({}, config.validateType);
|
|
this.validateFormat = Object.assign({}, config.validateFormat);
|
|
this.errors = Object.assign({}, config.errors);
|
|
this.setSchema(schema);
|
|
}
|
|
get rootSchema() {
|
|
return this.__rootSchema;
|
|
}
|
|
set rootSchema(rootSchema) {
|
|
if (rootSchema == null) {
|
|
return;
|
|
}
|
|
this.__rootSchema = this.config.compileSchema(this, rootSchema);
|
|
}
|
|
/**
|
|
* register a json-schema to be referenced from another json-schema
|
|
* @param url - base-url of json-schema (aka id)
|
|
* @param schema - json-schema root
|
|
*/
|
|
addRemoteSchema(url, schema) {
|
|
this.config.addRemoteSchema(this, url, schema);
|
|
}
|
|
compileSchema(schema) {
|
|
var _a;
|
|
return this.config.compileSchema(this, schema, (_a = this.rootSchema) !== null && _a !== void 0 ? _a : schema);
|
|
}
|
|
createSchemaOf(data) {
|
|
return this.config.createSchemaOf(data);
|
|
}
|
|
/**
|
|
* Iterates over data, retrieving its schema
|
|
*
|
|
* @param data - the data to iterate
|
|
* @param callback - will be called with (schema, data, pointer) on each item
|
|
* @param [schema] - the schema matching the data. Defaults to rootSchema
|
|
* @param [pointer] - pointer to current data. Default to rootPointer
|
|
*/
|
|
each(data, callback, schema, pointer) {
|
|
return this.config.each(this, data, callback, schema, pointer);
|
|
}
|
|
eachSchema(callback, schema = this.rootSchema) {
|
|
return this.config.eachSchema(schema, callback);
|
|
}
|
|
getChildSchemaSelection(property, schema) {
|
|
return this.config.getChildSchemaSelection(this, property, schema);
|
|
}
|
|
/**
|
|
* Returns the json-schema of a data-json-pointer.
|
|
*
|
|
* To resolve dynamic schema where the type of json-schema is evaluated by
|
|
* its value, a data object has to be passed in options.
|
|
*
|
|
* Per default this function will return `undefined` for valid properties that
|
|
* do not have a defined schema. Use the option `withSchemaWarning: true` to
|
|
* receive an error with `code: schema-warning` containing the location of its
|
|
* last evaluated json-schema.
|
|
*
|
|
* Notes
|
|
* - uses draft.step to walk through data and schema
|
|
*
|
|
* @param draft
|
|
* @param pointer - json pointer in data to get the json schema for
|
|
* @param [options.data] - the data object, which includes the json pointers value. This is optional, as
|
|
* long as no oneOf, anyOf, etc statement is part of the pointers schema
|
|
* @param [options.schema] - the json schema to iterate. Defaults to draft.rootSchema
|
|
* @param [options.withSchemaWarning] - if true returns an error instead of `undefined` for valid properties missing a schema definition
|
|
* @return resolved json-schema object of requested json-pointer location
|
|
*/
|
|
getSchema(options) {
|
|
return this.config.getSchema(this, options);
|
|
}
|
|
/**
|
|
* Create data object matching the given schema
|
|
*
|
|
* @param [data] - optional template data
|
|
* @param [schema] - json schema, defaults to rootSchema
|
|
* @return created template data
|
|
*/
|
|
getTemplate(data, schema, opts = this.config.templateDefaultOptions) {
|
|
return this.config.getTemplate(this, data, schema, opts);
|
|
}
|
|
isValid(data, schema, pointer) {
|
|
return this.config.isValid(this, data, schema, pointer);
|
|
}
|
|
resolveAnyOf(data, schema, pointer) {
|
|
return this.config.resolveAnyOf(this, data, schema, pointer);
|
|
}
|
|
resolveAllOf(data, schema) {
|
|
return this.config.resolveAllOf(this, data, schema);
|
|
}
|
|
resolveRef(schema) {
|
|
return this.config.resolveRef(schema, this.rootSchema);
|
|
}
|
|
resolveOneOf(data, schema, pointer) {
|
|
return this.config.resolveOneOf(this, data, schema, pointer);
|
|
}
|
|
setSchema(schema) {
|
|
this.rootSchema = schema;
|
|
}
|
|
/**
|
|
* Returns the json-schema of the given object property or array item.
|
|
* e.g. it steps by one key into the data
|
|
*
|
|
* This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
|
|
* returns the correct schema.
|
|
*
|
|
* @param key - property-name or array-index
|
|
* @param schema - json schema of current data
|
|
* @param data - parent of key
|
|
* @param [pointer] - pointer to schema and data (parent of key)
|
|
* @return Schema or Error if failed resolving key
|
|
*/
|
|
step(key, schema, data, pointer) {
|
|
return this.config.step(this, key, schema, data, pointer);
|
|
}
|
|
/**
|
|
* Validate data by a json schema
|
|
*
|
|
* @param value - value to validate
|
|
* @param [schema] - json schema, defaults to rootSchema
|
|
* @param [pointer] - json pointer pointing to value (used for error-messages only)
|
|
* @return list of errors or empty
|
|
*/
|
|
validate(data, schema, pointer) {
|
|
return this.config.validate(this, data, schema, pointer);
|
|
}
|
|
}
|