Skip to content

S
slapos.core
Commit 3e5d9c4f authored by Rafael Monnerat's avatar Rafael Monnerat
Browse files
Options

slapos_jio: Replace validator and dereference on parameter editor 

   Replace tv4 by cfworker-jsonschema in order to support more recent schemas.
   Use ref-parser rather them custom expandSchema to build a expanded json schema.

    cfworker json schema was built from https://github.com/cfworker/cfworker/tree/main/packages/json-schema source code.
parent f7eb220e
Show whitespace changes
Inline Side-by-side
Showing with 1323 additions and 266 deletions
master/bt5/slapos_jio/PathTemplateItem/web_page_module/rjs_gadget_erp5_page_slap_load_schema_js.js
View file @ 3e5d9c4f
/*jslint nomen: true, maxlen: 200, indent: 2*/
/*global window, rJS, console, RSVP, jQuery, jIO, tv4, URI, JSON, $, btoa */
(function (window, rJS, $, RSVP, btoa, URI, tv4) {
/*global window, rJS, RSVP, btoa, URI, Validator, jIO, JSON, $RefParser */
(function (window, rJS, RSVP, btoa, URI, Validator, jIO, JSON, $RefParser) {
"use strict";
var gk = rJS(window);
function getJSON(url) {
var uri = URI(url),
headers = {},
......@@ -31,218 +29,62 @@
});
}
function resolveLocalReference(ref, schema) {
// 2 here is for #/
var i, ref_path = ref.substr(2, ref.length),
parts = ref_path.split("/");
if (parts.length === 1 && parts[0] === "") {
// It was uses #/ to reference the entire json so just return it.
return schema;
}
for (i = 0; i < parts.length; i += 1) {
schema = schema[parts[i]];
}
return schema;
}
function resolveReference(partial_schema, schema, base_url) {
var parts,
external_schema,
ref = partial_schema.$ref;
if (ref === undefined) {
return new RSVP.Queue().push(function () {
return partial_schema;
});
}
if (ref.substr(0, 1) === "#") {
return new RSVP.Queue().push(function () {
return resolveLocalReference(ref, schema);
});
}
return new RSVP.Queue().push(function () {
if (URI(ref).protocol() === "") {
if (base_url !== undefined) {
ref = base_url + "/" + ref;
}
}
return getJSON(ref);
})
.push(function (json) {
external_schema = JSON.parse(json);
parts = ref.split("#");
ref = "#" + parts[1];
return resolveLocalReference(ref, external_schema);
});
}
function clone(obj) {
return JSON.parse(JSON.stringify(obj));
}
// Inspired from https://github.com/nexedi/dream/blob/master/dream/platform/src/jsplumb/jsplumb.js#L398
function expandSchema(json_schema, full_schema, base_url) {
var i,
expanded_json_schema = clone(json_schema) || {};
if (!expanded_json_schema.properties) {
expanded_json_schema.properties = {};
}
return new RSVP.Queue().push(function () {
if (json_schema.$ref) {
return resolveReference(
json_schema,
full_schema,
base_url
)
.push(function (remote_schema) {
return expandSchema(
remote_schema,
full_schema,
base_url
);
}).push(function (referencedx) {
$.extend(expanded_json_schema, referencedx);
delete expanded_json_schema.$ref;
return true;
});
}
return true;
}).push(function () {
var property, queue = new RSVP.Queue();
function wrapperResolveReference(p) {
return resolveReference(
json_schema.properties[p],
full_schema,
base_url
).push(function (external_schema) {
// console.log(p);
return expandSchema(
external_schema,
full_schema,
base_url
)
.push(function (referencedx) {
$.extend(expanded_json_schema.properties[p], referencedx);
if (json_schema.properties[p].$ref) {
delete expanded_json_schema.properties[p].$ref;
}
return referencedx;
});
});
}
// expand ref in properties
for (property in json_schema.properties) {
if (json_schema.properties.hasOwnProperty(property)) {
queue.push(
wrapperResolveReference.bind(this, property)
);
}
}
return queue;
})
.push(function () {
var zqueue = new RSVP.Queue();
function wrapperExpandSchema(p) {
return expandSchema(
json_schema.allOf[p],
full_schema,
base_url
).push(function (referencedx) {
if (referencedx.properties) {
$.extend(
expanded_json_schema.properties,
referencedx.properties
);
delete referencedx.properties;
}
$.extend(expanded_json_schema, referencedx);
});
}
if (json_schema.allOf) {
for (i = 0; i < json_schema.allOf.length; i += 1) {
zqueue.push(wrapperExpandSchema.bind(this, i));
}
}
return zqueue;
rJS(window)
.declareMethod("getBaseUrl", function (url) {
var base_url, url_uri = URI(url);
base_url = url_uri.path().split("/");
base_url.pop();
base_url = url.split(url_uri.path())[0] + base_url.join("/");
return base_url;
})
.push(function () {
if (expanded_json_schema.allOf) {
delete expanded_json_schema.allOf;
}
if (expanded_json_schema.$ref) {
delete expanded_json_schema.$ref;
}
// console.log(expanded_json_schema);
return clone(expanded_json_schema);
});
}
.declareMethod("loadJSONSchema", function (url, serialisation) {
var meta_schema_url = "slapos_load_meta_schema.json";
function getMetaJSONSchema(serialisation) {
if (serialisation === "xml") {
return getJSON("slapos_load_meta_schema_xml.json");
meta_schema_url = "slapos_load_meta_schema_xml.json";
}
if (serialisation === "json-in-xml") {
return getJSON("slapos_load_meta_schema_json_in_xml.json");
meta_schema_url = "slapos_load_meta_schema_json_in_xml.json";
}
return getJSON("slapos_load_meta_schema.json");
}
function validateJSONSchema(json, base_url, serialisation) {
return getMetaJSONSchema(serialisation)
return getJSON(meta_schema_url)
.push(function (meta_schema) {
if (!tv4.validate(json, meta_schema)) {
throw new Error("Non valid JSON schema " + json);
}
return JSON.parse(json);
})
.push(function (schema) {
return expandSchema(schema, schema, base_url);
return new RSVP.Queue()
.push(function () {
return $RefParser
.dereference(url)
.then(function (schema) {
return schema;
});
}
function validateSoftwareJSONSchema(json) {
return getJSON("slapos_load_software_schema.json")
})
.push(function (schema) {
if (!tv4.validate(json, schema)) {
throw new Error("Non valid JSON for software.cfg.json:" + json);
}
return JSON.parse(json);
});
var validator = new Validator(JSON.parse(meta_schema), '7');
if (!validator.validate(schema)) {
throw new Error("Non valid JSON schema " + JSON.stringify(schema));
}
gk
.declareMethod("getBaseUrl", function (url) {
var base_url, url_uri = URI(url);
base_url = url_uri.path().split("/");
base_url.pop();
base_url = url.split(url_uri.path())[0] + base_url.join("/");
return base_url;
})
.declareMethod("loadJSONSchema", function (url, serialisation) {
var gadget = this;
return getJSON(url)
.push(function (json) {
return gadget.getBaseUrl(url)
.push(function (base_url) {
return validateJSONSchema(json, base_url, serialisation);
return schema;
});
});
})
.declareMethod("loadSoftwareJSON", function (url) {
return getJSON(url)
.push(function (json) {
return validateSoftwareJSONSchema(json);
.push(function (software_cfg_json) {
return new RSVP.Queue()
.push(function () {
return $RefParser
.dereference("slapos_load_software_schema.json")
.then(function (software_schema) {
return software_schema;
});
})
.push(function (software_schema) {
var software_json = JSON.parse(software_cfg_json),
validator = new Validator(software_schema, '7');
if (!validator.validate(software_json)) {
throw new Error("Non valid JSON for software.cfg.json:" + software_cfg_json);
}
return software_json;
});
});
})
......@@ -255,13 +97,16 @@
}
}
return getJSON(parameter_schema_url)
.push(function (json) {
var schema = JSON.parse(json);
return expandSchema(schema, schema, base_url)
.push(function (loaded_json) {
return tv4.validateMultiple(generated_json, loaded_json);
return new RSVP.Queue()
.push(function () {
return $RefParser
.dereference(parameter_schema_url)
.then(function (schema) {
return schema;
});
})
.push(function (schema) {
return new Validator(schema, '7', false).validate(generated_json);
});
});
}(window, rJS, $, RSVP, btoa, URI, tv4));
}(window, rJS, RSVP, btoa, URI, Validator, jIO, JSON, $RefParser));
\ No newline at end of file
master/bt5/slapos_jio/PathTemplateItem/web_page_module/rjs_gadget_erp5_page_slap_load_schema_js.xml
View file @ 3e5d9c4f
......@@ -236,7 +236,7 @@
</item>
<item>
<key> <string>serial</string> </key>
<value> <string>982.28125.59086.62805</string> </value>
<value> <string>1003.49132.42731.30429</string> </value>
</item>
<item>
<key> <string>state</string> </key>
......@@ -254,7 +254,7 @@
</tuple>
<state>
<tuple>
<float>1583836689.5</float>
<float>1666203750.58</float>
<string>UTC</string>
</tuple>
</state>
......
master/bt5/slapos_jio/PathTemplateItem/web_page_module/rjs_gadget_erp5_page_slap_parameter_form_js.js
View file @ 3e5d9c4f
......@@ -3,7 +3,7 @@
jQuery, URI, vkbeautify, domsugar, Boolean */
(function (window, document, rJS, $, XMLSerializer, jQuery, vkbeautify,
loopEventListener, domsugar, Boolean) {
domsugar, Boolean) {
"use strict";
var DISPLAY_JSON_FORM = 'display_json_form',
......@@ -268,6 +268,15 @@
}
}
for (key in json_field.allOf) {
if (json_field.allOf.hasOwnProperty(key)) {
render_subform(json_field.allOf[key],
default_dict,
root,
path);
}
}
for (key in json_field.properties) {
if (json_field.properties.hasOwnProperty(key)) {
div = document.createElement("div");
......@@ -291,7 +300,10 @@
path + "/" + key);
} else {
input = render_field(
json_field.properties[key], default_dict[key], is_required);
json_field.properties[key],
default_dict[key],
is_required
);
input.name = path + "/" + key;
input.setAttribute("class", "slapos-parameter");
input.setAttribute("placeholder", " ");
......@@ -577,11 +589,9 @@
parameter_hash_input = g.element.querySelectorAll('.parameter_hash_output')[0],
field_name,
div,
divm,
missing_index,
missing_field_name,
xml_output,
input_field;
input_field,
error_dict;
$(g.element.querySelectorAll("span.error")).each(function (i, span) {
span.textContent = "";
......@@ -590,21 +600,20 @@
$(g.element.querySelectorAll("div.error-input")).each(function (i, div) {
div.setAttribute("class", "");
});
if (serialisation_type === "json-in-xml") {
xml_output = jsonDictToParameterJSONInXML(json_dict);
} else {
xml_output = jsonDictToParameterXML(json_dict);
}
parameter_hash_input.value = btoa(xml_output);
// g.options.value.parameter.parameter_hash = btoa(xml_output);
// console.log(parameter_hash_input.value);
// console.log(xml_output);
if (validation.valid) {
return xml_output;
}
// Update fields if errors exist
for (error_index in validation.errors) {
if (validation.errors.hasOwnProperty(error_index)) {
field_name = validation.errors[error_index].dataPath;
error_dict = validation.errors[error_index];
// error_dict = { error : "", instanceLocation: "#", keyword: "", keywordLocation: "" }
field_name = error_dict.instanceLocation.slice(1);
if (field_name !== "") {
input_field = g.element.querySelector(".slapos-parameter[name='/" + field_name + "']");
if (input_field === null) {
......@@ -613,34 +622,22 @@
}
div = input_field.parentNode;
div.setAttribute("class", "slapos-parameter error-input");
div.querySelector("span.error").textContent = validation.errors[error_index].message;
} else if (validation.errors[error_index].code == "302") {
// OBJECT_REQUIRED use case
field_name = "/" + validation.errors[error_index].params.key;
div.querySelector("span.error").textContent = validation.errors[error_index].error;
} else if (error_dict.keyword === "required") {
// Specific use case for required
field_name = "/" + error_dict.key;
input_field = g.element.querySelector(".slapos-parameter[name='/" + field_name + "']");
if (input_field === null) {
field_name = field_name.split("/").slice(0, -1).join("/");
input_field = g.element.querySelector(".slapos-parameter[name='/" + field_name + "']");
}
if (input_field !== null) {
div = input_field.parentNode;
div.setAttribute("class", "slapos-parameter error-input");
div.querySelector("span.error").textContent = validation.errors[error_index].message;
div.querySelector("span.error").textContent = error_dict.error;
}
}
}
for (missing_index in validation.missing) {
if (validation.missing.hasOwnProperty(missing_index)) {
missing_field_name = validation.missing[missing_index].dataPath;
input_field = g.element.querySelector(".slapos-parameter[name='/" + missing_field_name + "']");
if (input_field === null) {
missing_field_name = field_name.split("/").slice(0, -1).join("/");
input_field = g.element.querySelector(".slapos-parameter[name='/" + missing_field_name + "']");
}
divm = input_field.parentNode;
divm.setAttribute("class", "error-input");
divm.querySelector("span.error").textContent = validation.missing[missing_index].message;
}
}
return xml_output;
});
......@@ -1105,22 +1102,5 @@
});
}, {mutex: 'statechange'});
//.declareService(function () {
// var gadget = this;
//return gadget.processValidation(gadget.options.json_url)
// .fail(function (error) {
// var parameter_xml = '';
// console.log(error.stack);
// if (gadget.options.value.parameter.parameter_hash !== undefined) {
// parameter_xml = atob(gadget.options.value.parameter.parameter_hash);
// }
// return gadget.renderFailoverTextArea(parameter_xml, error.toString())
// .push(function () {
// error = undefined;
// return gadget;
// });
// });
//});
}(window, document, rJS, $, XMLSerializer, jQuery, vkbeautify,
rJS.loopEventListener, domsugar, Boolean));
\ No newline at end of file
domsugar, Boolean));
\ No newline at end of file
master/bt5/slapos_jio/PathTemplateItem/web_page_module/rjs_gadget_erp5_page_slap_parameter_form_js.xml
View file @ 3e5d9c4f
......@@ -280,7 +280,7 @@
</item>
<item>
<key> <string>serial</string> </key>
<value> <string>1003.46178.61021.55398</string> </value>
<value> <string>1003.49163.51970.27118</string> </value>
</item>
<item>
<key> <string>state</string> </key>
......@@ -298,7 +298,7 @@
</tuple>
<state>
<tuple>
<float>1666027007.74</float>
<float>1666206917.22</float>
<string>UTC</string>
</tuple>
</state>
......
master/bt5/slapos_jio/SkinTemplateItem/portal_skins/slapos_hal_json_style/cfworker-jsonschema-validator.js.js 0 → 100644
View file @ 3e5d9c4f
// pointer.js
function encodePointer(p) {
return encodeURI(escapePointer(p));
}
function escapePointer(p) {
return p.replace(/~/g, '~0').replace(/\//g, '~1');
}
// dereference.js
const schemaKeyword = {
additionalItems: true,
unevaluatedItems: true,
items: true,
contains: true,
additionalProperties: true,
unevaluatedProperties: true,
propertyNames: true,
not: true,
if: true,
then: true,
else: true
};
const schemaArrayKeyword = {
prefixItems: true,
items: true,
allOf: true,
anyOf: true,
oneOf: true
};
const schemaMapKeyword = {
$defs: true,
definitions: true,
properties: true,
patternProperties: true,
dependentSchemas: true
};
const ignoredKeyword = {
id: true,
$id: true,
$ref: true,
$schema: true,
$anchor: true,
$vocabulary: true,
$comment: true,
default: true,
enum: true,
const: true,
required: true,
type: true,
maximum: true,
minimum: true,
exclusiveMaximum: true,
exclusiveMinimum: true,
multipleOf: true,
maxLength: true,
minLength: true,
pattern: true,
format: true,
maxItems: true,
minItems: true,
uniqueItems: true,
maxProperties: true,
minProperties: true
};
let initialBaseURI = typeof self !== 'undefined' && self.location
?
new URL(self.location.origin + self.location.pathname + location.search)
: new URL('https://github.com/cfworker');
function dereference(schema, lookup = Object.create(null), baseURI = initialBaseURI, basePointer = '') {
if (schema && typeof schema === 'object' && !Array.isArray(schema)) {
const id = schema.$id || schema.id;
if (id) {
const url = new URL(id, baseURI.href);
if (url.hash.length > 1) {
lookup[url.href] = schema;
}
else {
url.hash = '';
if (basePointer === '') {
baseURI = url;
}
else {
dereference(schema, lookup, baseURI);
}
}
}
}
else if (schema !== true && schema !== false) {
return lookup;
}
const schemaURI = baseURI.href + (basePointer ? '#' + basePointer : '');
if (lookup[schemaURI] !== undefined) {
throw new Error(`Duplicate schema URI "${schemaURI}".`);
}
lookup[schemaURI] = schema;
if (schema === true || schema === false) {
return lookup;
}
if (schema.__absolute_uri__ === undefined) {
Object.defineProperty(schema, '__absolute_uri__', {
enumerable: false,
value: schemaURI
});
}
if (schema.$ref && schema.__absolute_ref__ === undefined) {
const url = new URL(schema.$ref, baseURI.href);
url.hash = url.hash;
Object.defineProperty(schema, '__absolute_ref__', {
enumerable: false,
value: url.href
});
}
if (schema.$recursiveRef && schema.__absolute_recursive_ref__ === undefined) {
const url = new URL(schema.$recursiveRef, baseURI.href);
url.hash = url.hash;
Object.defineProperty(schema, '__absolute_recursive_ref__', {
enumerable: false,
value: url.href
});
}
if (schema.$anchor) {
const url = new URL('#' + schema.$anchor, baseURI.href);
lookup[url.href] = schema;
}
for (let key in schema) {
if (ignoredKeyword[key]) {
continue;
}
const keyBase = `${basePointer}/${encodePointer(key)}`;
const subSchema = schema[key];
if (Array.isArray(subSchema)) {
if (schemaArrayKeyword[key]) {
const length = subSchema.length;
for (let i = 0; i < length; i++) {
dereference(subSchema[i], lookup, baseURI, `${keyBase}/${i}`);
}
}
}
else if (schemaMapKeyword[key]) {
for (let subKey in subSchema) {
dereference(subSchema[subKey], lookup, baseURI, `${keyBase}/${encodePointer(subKey)}`);
}
}
else {
dereference(subSchema, lookup, baseURI, keyBase);
}
}
return lookup;
}
// validator.js
// import { deepCompareStrict } from './deep-compare-strict.js';
function deepCompareStrict(a, b) {
const typeofa = typeof a;
if (typeofa !== typeof b) {
return false;
}
if (Array.isArray(a)) {
if (!Array.isArray(b)) {
return false;
}
const length = a.length;
if (length !== b.length) {
return false;
}
for (let i = 0; i < length; i++) {
if (!deepCompareStrict(a[i], b[i])) {
return false;
}
}
return true;
}
if (typeofa === 'object') {
if (!a || !b) {
return a === b;
}
const aKeys = Object.keys(a);
const bKeys = Object.keys(b);
const length = aKeys.length;
if (length !== bKeys.length) {
return false;
}
for (const k of aKeys) {
if (!deepCompareStrict(a[k], b[k])) {
return false;
}
}
return true;
}
return a === b;
}
// import { fastFormat } from './format.js';
const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
const TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
const HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
const URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
const URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
const URL_ = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
const JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
const JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
const RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
const FASTDATE = /^\d\d\d\d-[0-1]\d-[0-3]\d$/;
const FASTTIME = /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i;
const FASTDATETIME = /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i;
const FASTURIREFERENCE = /^(?:(?:[a-z][a-z0-9+-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i;
const EMAIL = (input) => {
if (input[0] === '"')
return false;
const [name, host, ...rest] = input.split('@');
if (!name ||
!host ||
rest.length !== 0 ||
name.length > 64 ||
host.length > 253)
return false;
if (name[0] === '.' || name.endsWith('.') || name.includes('..'))
return false;
if (!/^[a-z0-9.-]+$/i.test(host) ||
!/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name))
return false;
return host
.split('.')
.every(part => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part));
};
const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
const IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
const DURATION = (input) => input.length > 1 &&
input.length < 80 &&
(/^P\d+([.,]\d+)?W$/.test(input) ||
(/^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(input) &&
/^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(input)));
function bind(r) {
return r.test.bind(r);
}
const fullFormat = {
date,
time: time.bind(undefined, false),
'date-time': date_time,
duration: DURATION,
uri,
'uri-reference': bind(URIREF),
'uri-template': bind(URITEMPLATE),
url: bind(URL_),
email: EMAIL,
hostname: bind(HOSTNAME),
ipv4: bind(IPV4),
ipv6: bind(IPV6),
regex: regex,
uuid: bind(UUID),
'json-pointer': bind(JSON_POINTER),
'json-pointer-uri-fragment': bind(JSON_POINTER_URI_FRAGMENT),
'relative-json-pointer': bind(RELATIVE_JSON_POINTER)
};
const fastFormat = {
...fullFormat,
date: bind(FASTDATE),
time: bind(FASTTIME),
'date-time': bind(FASTDATETIME),
'uri-reference': bind(FASTURIREFERENCE)
};
function isLeapYear(year) {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
function date(str) {
const matches = str.match(DATE);
if (!matches)
return false;
const year = +matches[1];
const month = +matches[2];
const day = +matches[3];
return (month >= 1 &&
month <= 12 &&
day >= 1 &&
day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]));
}
function time(full, str) {
const matches = str.match(TIME);
if (!matches)
return false;
const hour = +matches[1];
const minute = +matches[2];
const second = +matches[3];
const timeZone = !!matches[5];
return (((hour <= 23 && minute <= 59 && second <= 59) ||
(hour == 23 && minute == 59 && second == 60)) &&
(!full || timeZone));
}
const DATE_TIME_SEPARATOR = /t|\s/i;
function date_time(str) {
const dateTime = str.split(DATE_TIME_SEPARATOR);
return dateTime.length == 2 && date(dateTime[0]) && time(true, dateTime[1]);
}
const NOT_URI_FRAGMENT = /\/|:/;
const URI_PATTERN = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
function uri(str) {
return NOT_URI_FRAGMENT.test(str) && URI_PATTERN.test(str);
}
const Z_ANCHOR = /[^\\]\\Z/;
function regex(str) {
if (Z_ANCHOR.test(str))
return false;
try {
new RegExp(str);
return true;
}
catch (e) {
return false;
}
}
//import { ucs2length } from './ucs2-length.js';
function ucs2length(s) {
let result = 0;
let length = s.length;
let index = 0;
let charCode;
while (index < length) {
result++;
charCode = s.charCodeAt(index++);
if (charCode >= 0xd800 && charCode <= 0xdbff && index < length) {
charCode = s.charCodeAt(index);
if ((charCode & 0xfc00) == 0xdc00) {
index++;
}
}
}
return result;
}
// validate.js
function validate(instance, schema, draft = '2019-09', lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = '#', schemaLocation = '#', evaluated = Object.create(null)) {
if (schema === true) {
return { valid: true, errors: [] };
}
if (schema === false) {
return {
valid: false,
errors: [
{
instanceLocation,
keyword: 'false',
keywordLocation: instanceLocation,
error: 'False boolean schema.'
}
]
};
}
const rawInstanceType = typeof instance;
let instanceType;
switch (rawInstanceType) {
case 'boolean':
case 'number':
case 'string':
instanceType = rawInstanceType;
break;
case 'object':
if (instance === null) {
instanceType = 'null';
}
else if (Array.isArray(instance)) {
instanceType = 'array';
}
else {
instanceType = 'object';
}
break;
default:
throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
}
const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
const errors = [];
if ($recursiveAnchor === true && recursiveAnchor === null) {
recursiveAnchor = schema;
}
if ($recursiveRef === '#') {
const refSchema = recursiveAnchor === null
? lookup[__absolute_recursive_ref__]
: recursiveAnchor;
const keywordLocation = `${schemaLocation}/$recursiveRef`;
const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
if (!result.valid) {
errors.push({
instanceLocation,
keyword: '$recursiveRef',
keywordLocation,
error: 'A subschema had errors.'
}, ...result.errors);
}
}
if ($ref !== undefined) {
const uri = __absolute_ref__ || $ref;
const refSchema = lookup[uri];
if (refSchema === undefined) {
let message = `Unresolved $ref "${$ref}".`;
if (__absolute_ref__ && __absolute_ref__ !== $ref) {
message += ` Absolute URI "${__absolute_ref__}".`;
}
message += `\nKnown schemas:\n- ${Object.keys(lookup).join('\n- ')}`;
throw new Error(message);
}
const keywordLocation = `${schemaLocation}/$ref`;
const result = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
if (!result.valid) {
errors.push({
instanceLocation,
keyword: '$ref',
keywordLocation,
error: 'A subschema had errors.'
}, ...result.errors);
}
if (draft === '4' || draft === '7') {
return { valid: errors.length === 0, errors };
}
}
if (Array.isArray($type)) {
let length = $type.length;
let valid = false;
for (let i = 0; i < length; i++) {
if (instanceType === $type[i] ||
($type[i] === 'integer' &&
instanceType === 'number' &&
instance % 1 === 0 &&
instance === instance)) {
valid = true;
break;
}
}
if (!valid) {
errors.push({
instanceLocation,
keyword: 'type',
keywordLocation: `${schemaLocation}/type`,
error: `Instance type "${instanceType}" is invalid. Expected "${$type.join('", "')}".`
});
}
}
else if ($type === 'integer') {
if (instanceType !== 'number' || instance % 1 || instance !== instance) {
errors.push({
instanceLocation,
keyword: 'type',
keywordLocation: `${schemaLocation}/type`,
error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
});
}
}
else if ($type !== undefined && instanceType !== $type) {
errors.push({
instanceLocation,
keyword: 'type',
keywordLocation: `${schemaLocation}/type`,
error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
});
}
if ($const !== undefined) {
if (instanceType === 'object' || instanceType === 'array') {
if (!deepCompareStrict(instance, $const)) {
errors.push({
instanceLocation,
keyword: 'const',
keywordLocation: `${schemaLocation}/const`,
error: `Instance does not match ${JSON.stringify($const)}.`
});
}
}
else if (instance !== $const) {
errors.push({
instanceLocation,
keyword: 'const',
keywordLocation: `${schemaLocation}/const`,
error: `Instance does not match ${JSON.stringify($const)}.`
});
}
}
if ($enum !== undefined) {
if (instanceType === 'object' || instanceType === 'array') {
if (!$enum.some(value => deepCompareStrict(instance, value))) {
errors.push({
instanceLocation,
keyword: 'enum',
keywordLocation: `${schemaLocation}/enum`,
error: `Instance does not match any of ${JSON.stringify($enum)}.`
});
}
}
else if (!$enum.some(value => instance === value)) {
errors.push({
instanceLocation,
keyword: 'enum',
keywordLocation: `${schemaLocation}/enum`,
error: `Instance does not match any of ${JSON.stringify($enum)}.`
});
}
}
if ($not !== undefined) {
const keywordLocation = `${schemaLocation}/not`;
const result = validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation);
if (result.valid) {
errors.push({
instanceLocation,
keyword: 'not',
keywordLocation,
error: 'Instance matched "not" schema.'
});
}
}
let subEvaluateds = [];
if ($anyOf !== undefined) {
const keywordLocation = `${schemaLocation}/anyOf`;
const errorsLength = errors.length;
let anyValid = false;
for (let i = 0; i < $anyOf.length; i++) {
const subSchema = $anyOf[i];
const subEvaluated = Object.create(evaluated);
const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
errors.push(...result.errors);
anyValid = anyValid || result.valid;
if (result.valid) {
subEvaluateds.push(subEvaluated);
}
}
if (anyValid) {
errors.length = errorsLength;
}
else {
errors.splice(errorsLength, 0, {
instanceLocation,
keyword: 'anyOf',
keywordLocation,
error: 'Instance does not match any subschemas.'
});
}
}
if ($allOf !== undefined) {
const keywordLocation = `${schemaLocation}/allOf`;
const errorsLength = errors.length;
let allValid = true;
for (let i = 0; i < $allOf.length; i++) {
const subSchema = $allOf[i];
const subEvaluated = Object.create(evaluated);
const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
errors.push(...result.errors);
allValid = allValid && result.valid;
if (result.valid) {
subEvaluateds.push(subEvaluated);
}
}
if (allValid) {
errors.length = errorsLength;
}
else {
errors.splice(errorsLength, 0, {
instanceLocation,
keyword: 'allOf',
keywordLocation,
error: `Instance does not match every subschema.`
});
}
}
if ($oneOf !== undefined) {
const keywordLocation = `${schemaLocation}/oneOf`;
const errorsLength = errors.length;
const matches = $oneOf.filter((subSchema, i) => {
const subEvaluated = Object.create(evaluated);
const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
errors.push(...result.errors);
if (result.valid) {
subEvaluateds.push(subEvaluated);
}
return result.valid;
}).length;
if (matches === 1) {
errors.length = errorsLength;
}
else {
errors.splice(errorsLength, 0, {
instanceLocation,
keyword: 'oneOf',
keywordLocation,
error: `Instance does not match exactly one subschema (${matches} matches).`
});
}
}
if (instanceType === 'object' || instanceType === 'array') {
Object.assign(evaluated, ...subEvaluateds);
}
if ($if !== undefined) {
const keywordLocation = `${schemaLocation}/if`;
const conditionResult = validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid;
if (conditionResult) {
if ($then !== undefined) {
const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
if (!thenResult.valid) {
errors.push({
instanceLocation,
keyword: 'if',
keywordLocation,
error: `Instance does not match "then" schema.`
}, ...thenResult.errors);
}
}
}
else if ($else !== undefined) {
const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
if (!elseResult.valid) {
errors.push({
instanceLocation,
keyword: 'if',
keywordLocation,
error: `Instance does not match "else" schema.`
}, ...elseResult.errors);
}
}
}
if (instanceType === 'object') {
if ($required !== undefined) {
for (const key of $required) {
if (!(key in instance)) {
errors.push({
instanceLocation,
keyword: 'required',
keywordLocation: `${schemaLocation}/required`,
// XXX expose key for make search of the field easier
key: key,
error: `Instance does not have required property "${key}".`
});
}
}
}
const keys = Object.keys(instance);
if ($minProperties !== undefined && keys.length < $minProperties) {
errors.push({
instanceLocation,
keyword: 'minProperties',
keywordLocation: `${schemaLocation}/minProperties`,
error: `Instance does not have at least ${$minProperties} properties.`
});
}
if ($maxProperties !== undefined && keys.length > $maxProperties) {
errors.push({
instanceLocation,
keyword: 'maxProperties',
keywordLocation: `${schemaLocation}/maxProperties`,
error: `Instance does not have at least ${$maxProperties} properties.`
});
}
if ($propertyNames !== undefined) {
const keywordLocation = `${schemaLocation}/propertyNames`;
for (const key in instance) {
const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
const result = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
if (!result.valid) {
errors.push({
instanceLocation,
keyword: 'propertyNames',
keywordLocation,
error: `Property name "${key}" does not match schema.`
}, ...result.errors);
}
}
}
if ($dependentRequired !== undefined) {
const keywordLocation = `${schemaLocation}/dependantRequired`;
for (const key in $dependentRequired) {
if (key in instance) {
const required = $dependentRequired[key];
for (const dependantKey of required) {
if (!(dependantKey in instance)) {
errors.push({
instanceLocation,
keyword: 'dependentRequired',
keywordLocation,
error: `Instance has "${key}" but does not have "${dependantKey}".`
});
}
}
}
}
}
if ($dependentSchemas !== undefined) {
for (const key in $dependentSchemas) {
const keywordLocation = `${schemaLocation}/dependentSchemas`;
if (key in instance) {
const result = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
if (!result.valid) {
errors.push({
instanceLocation,
keyword: 'dependentSchemas',
keywordLocation,
error: `Instance has "${key}" but does not match dependant schema.`
}, ...result.errors);
}
}
}
}
if ($dependencies !== undefined) {
const keywordLocation = `${schemaLocation}/dependencies`;
for (const key in $dependencies) {
if (key in instance) {
const propsOrSchema = $dependencies[key];
if (Array.isArray(propsOrSchema)) {
for (const dependantKey of propsOrSchema) {
if (!(dependantKey in instance)) {
errors.push({
instanceLocation,
keyword: 'dependencies',
keywordLocation,
error: `Instance has "${key}" but does not have "${dependantKey}".`
});
}
}
}
else {
const result = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
if (!result.valid) {
errors.push({
instanceLocation,
keyword: 'dependencies',
keywordLocation,
error: `Instance has "${key}" but does not match dependant schema.`
}, ...result.errors);
}
}
}
}
}
const thisEvaluated = Object.create(null);
let stop = false;
if ($properties !== undefined) {
const keywordLocation = `${schemaLocation}/properties`;
for (const key in $properties) {
if (!(key in instance)) {
continue;
}
const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
const result = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
if (result.valid) {
evaluated[key] = thisEvaluated[key] = true;
}
else {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'properties',
keywordLocation,
error: `Property "${key}" does not match schema.`
}, ...result.errors);
if (stop)
break;
}
}
}
if (!stop && $patternProperties !== undefined) {
const keywordLocation = `${schemaLocation}/patternProperties`;
for (const pattern in $patternProperties) {
const regex = new RegExp(pattern);
const subSchema = $patternProperties[pattern];
for (const key in instance) {
if (!regex.test(key)) {
continue;
}
const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
const result = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
if (result.valid) {
evaluated[key] = thisEvaluated[key] = true;
}
else {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'patternProperties',
keywordLocation,
error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
}, ...result.errors);
}
}
}
}
if (!stop && $additionalProperties !== undefined) {
const keywordLocation = `${schemaLocation}/additionalProperties`;
for (const key in instance) {
if (thisEvaluated[key]) {
continue;
}
const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
const result = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
if (result.valid) {
evaluated[key] = true;
}
else {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'additionalProperties',
keywordLocation,
error: `Property "${key}" does not match additional properties schema.`
}, ...result.errors);
}
}
}
else if (!stop && $unevaluatedProperties !== undefined) {
const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
for (const key in instance) {
if (!evaluated[key]) {
const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
const result = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
if (result.valid) {
evaluated[key] = true;
}
else {
errors.push({
instanceLocation,
keyword: 'unevaluatedProperties',
keywordLocation,
error: `Property "${key}" does not match unevaluated properties schema.`
}, ...result.errors);
}
}
}
}
}
else if (instanceType === 'array') {
if ($maxItems !== undefined && instance.length > $maxItems) {
errors.push({
instanceLocation,
keyword: 'maxItems',
keywordLocation: `${schemaLocation}/maxItems`,
error: `Array has too many items (${instance.length} > ${$maxItems}).`
});
}
if ($minItems !== undefined && instance.length < $minItems) {
errors.push({
instanceLocation,
keyword: 'minItems',
keywordLocation: `${schemaLocation}/minItems`,
error: `Array has too few items (${instance.length} < ${$minItems}).`
});
}
const length = instance.length;
let i = 0;
let stop = false;
if ($prefixItems !== undefined) {
const keywordLocation = `${schemaLocation}/prefixItems`;
const length2 = Math.min($prefixItems.length, length);
for (; i < length2; i++) {
const result = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
evaluated[i] = true;
if (!result.valid) {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'prefixItems',
keywordLocation,
error: `Items did not match schema.`
}, ...result.errors);
if (stop)
break;
}
}
}
if ($items !== undefined) {
const keywordLocation = `${schemaLocation}/items`;
if (Array.isArray($items)) {
const length2 = Math.min($items.length, length);
for (; i < length2; i++) {
const result = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
evaluated[i] = true;
if (!result.valid) {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'items',
keywordLocation,
error: `Items did not match schema.`
}, ...result.errors);
if (stop)
break;
}
}
}
else {
for (; i < length; i++) {
const result = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
evaluated[i] = true;
if (!result.valid) {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'items',
keywordLocation,
error: `Items did not match schema.`
}, ...result.errors);
if (stop)
break;
}
}
}
if (!stop && $additionalItems !== undefined) {
const keywordLocation = `${schemaLocation}/additionalItems`;
for (; i < length; i++) {
const result = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
evaluated[i] = true;
if (!result.valid) {
stop = shortCircuit;
errors.push({
instanceLocation,
keyword: 'additionalItems',
keywordLocation,
error: `Items did not match additional items schema.`
}, ...result.errors);
}
}
}
}
if ($contains !== undefined) {
if (length === 0 && $minContains === undefined) {
errors.push({
instanceLocation,
keyword: 'contains',
keywordLocation: `${schemaLocation}/contains`,
error: `Array is empty. It must contain at least one item matching the schema.`
});
}
else if ($minContains !== undefined && length < $minContains) {
errors.push({
instanceLocation,
keyword: 'minContains',
keywordLocation: `${schemaLocation}/minContains`,
error: `Array has less items (${length}) than minContains (${$minContains}).`
});
}
else {
const keywordLocation = `${schemaLocation}/contains`;
const errorsLength = errors.length;
let contained = 0;
for (let j = 0; j < length; j++) {
const result = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
if (result.valid) {
evaluated[j] = true;
contained++;
}
else {
errors.push(...result.errors);
}
}
if (contained >= ($minContains || 0)) {
errors.length = errorsLength;
}
if ($minContains === undefined &&
$maxContains === undefined &&
contained === 0) {
errors.splice(errorsLength, 0, {
instanceLocation,
keyword: 'contains',
keywordLocation,
error: `Array does not contain item matching schema.`
});
}
else if ($minContains !== undefined && contained < $minContains) {
errors.push({
instanceLocation,
keyword: 'minContains',
keywordLocation: `${schemaLocation}/minContains`,
error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
});
}
else if ($maxContains !== undefined && contained > $maxContains) {
errors.push({
instanceLocation,
keyword: 'maxContains',
keywordLocation: `${schemaLocation}/maxContains`,
error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
});
}
}
}
if (!stop && $unevaluatedItems !== undefined) {
const keywordLocation = `${schemaLocation}/unevaluatedItems`;
for (i; i < length; i++) {
if (evaluated[i]) {
continue;
}
const result = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
evaluated[i] = true;
if (!result.valid) {
errors.push({
instanceLocation,
keyword: 'unevaluatedItems',
keywordLocation,
error: `Items did not match unevaluated items schema.`
}, ...result.errors);
}
}
}
if ($uniqueItems) {
for (let j = 0; j < length; j++) {
const a = instance[j];
const ao = typeof a === 'object' && a !== null;
for (let k = 0; k < length; k++) {
if (j === k) {
continue;
}
const b = instance[k];
const bo = typeof b === 'object' && b !== null;
if (a === b || (ao && bo && deepCompareStrict(a, b))) {
errors.push({
instanceLocation,
keyword: 'uniqueItems',
keywordLocation: `${schemaLocation}/uniqueItems`,
error: `Duplicate items at indexes ${j} and ${k}.`
});
j = Number.MAX_SAFE_INTEGER;
k = Number.MAX_SAFE_INTEGER;
}
}
}
}
}
else if (instanceType === 'number') {
if (draft === '4') {
if ($minimum !== undefined &&
(($exclusiveMinimum === true && instance <= $minimum) ||
instance < $minimum)) {
errors.push({
instanceLocation,
keyword: 'minimum',
keywordLocation: `${schemaLocation}/minimum`,
error: `${instance} is less than ${$exclusiveMinimum ? 'or equal to ' : ''} ${$minimum}.`
});
}
if ($maximum !== undefined &&
(($exclusiveMaximum === true && instance >= $maximum) ||
instance > $maximum)) {
errors.push({
instanceLocation,
keyword: 'maximum',
keywordLocation: `${schemaLocation}/maximum`,
error: `${instance} is greater than ${$exclusiveMaximum ? 'or equal to ' : ''} ${$maximum}.`
});
}
}
else {
if ($minimum !== undefined && instance < $minimum) {
errors.push({
instanceLocation,
keyword: 'minimum',
keywordLocation: `${schemaLocation}/minimum`,
error: `${instance} is less than ${$minimum}.`
});
}
if ($maximum !== undefined && instance > $maximum) {
errors.push({
instanceLocation,
keyword: 'maximum',
keywordLocation: `${schemaLocation}/maximum`,
error: `${instance} is greater than ${$maximum}.`
});
}
if ($exclusiveMinimum !== undefined && instance <= $exclusiveMinimum) {
errors.push({
instanceLocation,
keyword: 'exclusiveMinimum',
keywordLocation: `${schemaLocation}/exclusiveMinimum`,
error: `${instance} is less than ${$exclusiveMinimum}.`
});
}
if ($exclusiveMaximum !== undefined && instance >= $exclusiveMaximum) {
errors.push({
instanceLocation,
keyword: 'exclusiveMaximum',
keywordLocation: `${schemaLocation}/exclusiveMaximum`,
error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
});
}
}
if ($multipleOf !== undefined) {
const remainder = instance % $multipleOf;
if (Math.abs(0 - remainder) >= 1.1920929e-7 &&
Math.abs($multipleOf - remainder) >= 1.1920929e-7) {
errors.push({
instanceLocation,
keyword: 'multipleOf',
keywordLocation: `${schemaLocation}/multipleOf`,
error: `${instance} is not a multiple of ${$multipleOf}.`
});
}
}
}
else if (instanceType === 'string') {
const length = $minLength === undefined && $maxLength === undefined
? 0
: ucs2length(instance);
if ($minLength !== undefined && length < $minLength) {
errors.push({
instanceLocation,
keyword: 'minLength',
keywordLocation: `${schemaLocation}/minLength`,
error: `String is too short (${length} < ${$minLength}).`
});
}
if ($maxLength !== undefined && length > $maxLength) {
errors.push({
instanceLocation,
keyword: 'maxLength',
keywordLocation: `${schemaLocation}/maxLength`,
error: `String is too long (${length} > ${$maxLength}).`
});
}
if ($pattern !== undefined && !new RegExp($pattern).test(instance)) {
errors.push({
instanceLocation,
keyword: 'pattern',
keywordLocation: `${schemaLocation}/pattern`,
error: `String does not match pattern.`
});
}
if ($format !== undefined &&
fastFormat[$format] &&
!fastFormat[$format](instance)) {
errors.push({
instanceLocation,
keyword: 'format',
keywordLocation: `${schemaLocation}/format`,
error: `String does not match format "${$format}".`
});
}
}
return { valid: errors.length === 0, errors };
}
// validator.js
class Validator {
constructor(schema, draft = '2019-09', shortCircuit = true) {
this.schema = schema;
this.draft = draft;
this.shortCircuit = shortCircuit;
this.lookup = dereference(schema);
}
validate(instance) {
return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
}
addSchema(schema, id) {
if (id) {
schema = { ...schema, $id: id };
}
dereference(schema, this.lookup);
}
}
master/bt5/slapos_jio/SkinTemplateItem/portal_skins/slapos_hal_json_style/cfworker-jsonschema-validator.js.xml 0 → 100644
View file @ 3e5d9c4f
<?xml version="1.0"?>
<ZopeData>
<record id="1" aka="AAAAAAAAAAE=">
<pickle>
<global name="File" module="OFS.Image"/>
</pickle>
<pickle>
<dictionary>
<item>
<key> <string>__name__</string> </key>
<value> <string>cfworker-jsonschema-validator.js</string> </value>
</item>
<item>
<key> <string>content_type</string> </key>
<value> <string>text/javascript</string> </value>
</item>
<item>
<key> <string>precondition</string> </key>
<value> <string></string> </value>
</item>
<item>
<key> <string>title</string> </key>
<value> <string>validator.js</string> </value>
</item>
</dictionary>
</pickle>
</record>
</ZopeData>
master/bt5/slapos_jio/SkinTemplateItem/portal_skins/slapos_hal_json_style/ref-parser.min.js.js 0 → 100644
View file @ 3e5d9c4f
This source diff could not be displayed because it is too large. You can view the blob instead.
master/bt5/slapos_jio/SkinTemplateItem/portal_skins/slapos_hal_json_style/ref-parser.min.js.xml 0 → 100644
View file @ 3e5d9c4f
<?xml version="1.0"?>
<ZopeData>
<record id="1" aka="AAAAAAAAAAE=">
<pickle>
<global name="File" module="OFS.Image"/>
</pickle>
<pickle>
<dictionary>
<item>
<key> <string>__name__</string> </key>
<value> <string>ref-parser.min.js</string> </value>
</item>
<item>
<key> <string>content_type</string> </key>
<value> <string>text/javascript</string> </value>
</item>
<item>
<key> <string>precondition</string> </key>
<value> <string></string> </value>
</item>
<item>
<key> <string>title</string> </key>
<value> <string></string> </value>
</item>
</dictionary>
</pickle>
</record>
</ZopeData>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7