RisvanaCybro
2 years ago
1840 changed files with 0 additions and 219168 deletions
@ -1,47 +0,0 @@ |
|||
.. image:: https://img.shields.io/badge/license-AGPL--3-blue.svg |
|||
:target: https://www.gnu.org/licenses/agpl-3.0-standalone.html |
|||
:alt: License: AGPL-3 |
|||
|
|||
Website Quotation Template Snippet |
|||
================================== |
|||
* This module allow to select quotation template in website and add products |
|||
directly into cart. |
|||
|
|||
Configuration |
|||
============= |
|||
* No Additional configuration is needed. |
|||
|
|||
License |
|||
------- |
|||
Affero General Public License v3.0 (AGPL v3) |
|||
(https://www.gnu.org/licenses/agpl-3.0-standalone.html) |
|||
|
|||
Company |
|||
------- |
|||
* `Cybrosys Techno Solutions <https://cybrosys.com/>`__ |
|||
|
|||
Credits |
|||
------- |
|||
Developer: (V16) Athira P S, Contact: odoo@cybrosys.com |
|||
|
|||
Contacts |
|||
-------- |
|||
* Mail Contact : odoo@cybrosys.com |
|||
* Website : https://cybrosys.com |
|||
|
|||
Bug Tracker |
|||
----------- |
|||
Bugs are tracked on GitHub Issues. In case of trouble, please check there if your issue has already been reported. |
|||
|
|||
Maintainer |
|||
========== |
|||
.. image:: https://cybrosys.com/images/logo.png |
|||
:target: https://cybrosys.com |
|||
|
|||
This module is maintained by Cybrosys Technologies. |
|||
|
|||
For support and more information, please visit `Our Website <https://cybrosys.com/>`__ |
|||
|
|||
Further information |
|||
=================== |
|||
HTML Description: `<static/description/index.html>`__ |
|||
@ -1,23 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from . import controllers |
|||
from . import models |
|||
@ -1,53 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
{ |
|||
'name': 'Website Quotation Template Snippet', |
|||
'version': '16.0.1.0.0', |
|||
'category': 'Website', |
|||
'summary': "Adding Quotation Template inside website", |
|||
'description': "Using this new website quotation template snippet,we can" |
|||
"directly add the products inside the selected quotation " |
|||
"template into the shopping cart.", |
|||
'author': 'Cybrosys Techno Solutions', |
|||
'company': 'Cybrosys Techno Solutions', |
|||
'maintainer': 'Cybrosys Techno Solutions', |
|||
'website': 'https://www.cybrosys.com', |
|||
'depends': ['sale_management', 'website_sale'], |
|||
'data': |
|||
[ |
|||
'views/sale_order_template_views.xml', |
|||
'views/website_quotation_snippet_templates.xml', |
|||
'views/product_details_templates.xml', |
|||
], |
|||
'assets': { |
|||
'web.assets_frontend': [ |
|||
'website_quotation_template/static/src/js/snippet.js', |
|||
'website_quotation_template/static/src/xml/snippet_template.xml', |
|||
'website_quotation_template/static/src/css/snippet.css', |
|||
], |
|||
}, |
|||
'images': ['static/description/banner.jpg'], |
|||
'license': 'AGPL-3', |
|||
'installable': True, |
|||
'auto_install': False, |
|||
'application': False, |
|||
} |
|||
@ -1,23 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira P S (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from . import website_sale |
|||
from . import website_quotation_template |
|||
@ -1,53 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from odoo import http |
|||
from odoo.http import request |
|||
|
|||
|
|||
class TemplateSnippet(http.Controller): |
|||
"""Adding website quotation template snippet""" |
|||
|
|||
@http.route('/quotation_template', methods=['POST'], type="json", |
|||
auth="public", website=True) |
|||
def website_quotation_template(self, **post): |
|||
"""Return details of products inside the quotation template.""" |
|||
templates = [ |
|||
{ |
|||
'name': temp.name, |
|||
'id': temp.id, |
|||
'is_available_in_website': temp.is_available_in_website, |
|||
'image': '/web/image?model=sale.order.template&id=' + str( |
|||
temp.id) + '&field=temp_img' |
|||
} |
|||
for temp in request.env['sale.order.template'].sudo().search([]) |
|||
] |
|||
return templates |
|||
|
|||
@http.route('/product/details/<int:product_id>', type='http', |
|||
auth="public", website=True) |
|||
def product_details(self, product_id, **kwargs): |
|||
"""Render the product details template for a specific sale order |
|||
template.""" |
|||
template = request.env['sale.order.template'].sudo().browse(product_id) |
|||
return http.request.render( |
|||
'website_quotation_template.product_details_template', |
|||
{'template': template}) |
|||
@ -1,77 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from odoo import http |
|||
from odoo.http import request |
|||
from odoo.addons.website_sale.controllers.main import WebsiteSale |
|||
|
|||
|
|||
class ProductAddToCart(WebsiteSale): |
|||
"""Class for add to cart.""" |
|||
|
|||
@http.route([ |
|||
'/shop', |
|||
'/shop/page/<int:page>', |
|||
'/shop/category/<model("product.public.category"):category>', |
|||
'/shop/category/<model("product.public.category"):category>/page/<int:page>', |
|||
], type='http', auth="public", website=True) |
|||
def shop(self, page=0, category=None, search='', min_price=0.0, |
|||
max_price=0.0, ppg=False, **post): |
|||
"""Perform a shopping operation. |
|||
Args: |
|||
page (int): The page number of the shop. |
|||
category (str): The category of products to filter. |
|||
search (str): The search keyword to filter products. |
|||
min_price (float): The minimum price of products to filter. |
|||
max_price (float): The maximum price of products to filter. |
|||
ppg (bool): Whether to paginate the results. |
|||
**post: Additional keyword arguments. |
|||
Returns: |
|||
A response object with updated context.""" |
|||
response = super(ProductAddToCart, self).shop(page, category, search, |
|||
min_price, max_price, |
|||
ppg, |
|||
**post) |
|||
response.qcontext.update( |
|||
val=request.env['sale.order.template'].sudo().search([])) |
|||
return response |
|||
|
|||
@http.route('/product/add_cart', type='http', auth="public", |
|||
methods=['POST'], website=True, csrf=False) |
|||
def cart_update_product(self, express=False, add_qty=1, set_qty=0, |
|||
product_custom_attribute_values=None, |
|||
no_variant_attribute_values=None, **kw): |
|||
"""Add products inside the quotation template into cart""" |
|||
order_temp = request.env['sale.order.template'].sudo().browse( |
|||
int(kw.get('prod_id'))) |
|||
sale_order = request.website.sale_get_order(force_create=True) |
|||
for products in order_temp.sale_order_template_line_ids: |
|||
sale_order._cart_update( |
|||
product_id=int(products.product_id), |
|||
add_qty=products.product_uom_qty, |
|||
set_qty=set_qty, |
|||
product_custom_attribute_values=product_custom_attribute_values, |
|||
no_variant_attribute_values=no_variant_attribute_values, **kw) |
|||
request.session[ |
|||
'website_sale_cart_quantity'] = sale_order.cart_quantity |
|||
if express: |
|||
return request.redirect("/shop/checkout?express=1") |
|||
return request.redirect("/shop/cart") |
|||
@ -1,6 +0,0 @@ |
|||
## Module <website_quotation_template> |
|||
|
|||
#### 01.02.2024 |
|||
#### Version 16.0.1.0.0 |
|||
#### ADD |
|||
- Initial commit for Website Quotation Template Snippet |
|||
@ -1,22 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from . import sale_order_template |
|||
@ -1,36 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
############################################################################### |
|||
# |
|||
# Cybrosys Technologies Pvt. Ltd. |
|||
# |
|||
# Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
|||
# Author: Athira PS (odoo@cybrosys.com) |
|||
# |
|||
# You can modify it under the terms of the GNU AFFERO |
|||
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details. |
|||
# |
|||
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE |
|||
# (AGPL v3) along with this program. |
|||
# If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
############################################################################### |
|||
from odoo import fields, models |
|||
|
|||
|
|||
class SaleOrderTemplate(models.Model): |
|||
"""Inherit sale order template""" |
|||
_inherit = 'sale.order.template' |
|||
|
|||
is_available_in_website = fields.Boolean(string="Is available in website", |
|||
help="Specifies whether this sale" |
|||
"order template is available" |
|||
"for purchase on the " |
|||
"website.") |
|||
temp_img = fields.Image(string="Template Image", |
|||
help="An image representing the sale order " |
|||
"template.") |
|||
@ -1,20 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
|
|||
var extract = require('./') |
|||
|
|||
var args = process.argv.slice(2) |
|||
var source = args[0] |
|||
var dest = args[1] || process.cwd() |
|||
if (!source) { |
|||
console.error('Usage: extract-zip foo.zip <targetDirectory>') |
|||
process.exit(1) |
|||
} |
|||
|
|||
extract(source, {dir: dest}, function (err, results) { |
|||
if (err) { |
|||
console.error('error!', err) |
|||
process.exit(1) |
|||
} else { |
|||
process.exit(0) |
|||
} |
|||
}) |
|||
@ -1,32 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
|
|||
var fs = require('fs') |
|||
var pdf = require('../') |
|||
var path = require('path') |
|||
|
|||
var args = process.argv.slice(2) |
|||
|
|||
if (args.length >= 2) { |
|||
htmlpdf(args[0], args[1]) |
|||
} else { |
|||
help() |
|||
} |
|||
|
|||
function help () { |
|||
var help = [ |
|||
'Usage: html-pdf <source> <destination>', |
|||
'e.g.: html-pdf source.html destination.pdf' |
|||
].join('\n') |
|||
|
|||
console.log(help) |
|||
} |
|||
|
|||
function htmlpdf (source, destination) { |
|||
var html = fs.readFileSync(source, 'utf8') |
|||
var options = { |
|||
base: 'file://' + path.resolve(source) |
|||
} |
|||
pdf.create(html, options).toFile(destination, function (err, res) { |
|||
if (err) throw err |
|||
}) |
|||
} |
|||
@ -1,38 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
|
|||
var ArgumentParser = require("argparse").ArgumentParser; |
|||
var main = require("../lib/main"); |
|||
|
|||
var parser = new ArgumentParser({ |
|||
addHelp: true |
|||
}); |
|||
|
|||
parser.addArgument(["docx-path"], { |
|||
type: "string", |
|||
help: "Path to the .docx file to convert." |
|||
}); |
|||
|
|||
var outputGroup = parser.addMutuallyExclusiveGroup(); |
|||
outputGroup.addArgument(["output-path"], { |
|||
type: "string", |
|||
nargs: "?", |
|||
help: "Output path for the generated document. Images will be stored inline in the output document. Output is written to stdout if not set." |
|||
}); |
|||
outputGroup.addArgument(["--output-dir"], { |
|||
type: "string", |
|||
help: "Output directory for generated HTML and images. Images will be stored in separate files. Mutually exclusive with output-path." |
|||
}); |
|||
|
|||
parser.addArgument(["--output-format"], { |
|||
defaultValue: "html", |
|||
choices: ["html", "markdown"], |
|||
help: "Output format." |
|||
}); |
|||
|
|||
parser.addArgument(["--style-map"], { |
|||
type: "string", |
|||
help: "File containg a style map." |
|||
}); |
|||
|
|||
|
|||
main(parser.parseArgs()); |
|||
@ -1,33 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
|
|||
var mkdirp = require('../'); |
|||
var minimist = require('minimist'); |
|||
var fs = require('fs'); |
|||
|
|||
var argv = minimist(process.argv.slice(2), { |
|||
alias: { m: 'mode', h: 'help' }, |
|||
string: [ 'mode' ] |
|||
}); |
|||
if (argv.help) { |
|||
fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout); |
|||
return; |
|||
} |
|||
|
|||
var paths = argv._.slice(); |
|||
var mode = argv.mode ? parseInt(argv.mode, 8) : undefined; |
|||
|
|||
(function next () { |
|||
if (paths.length === 0) return; |
|||
var p = paths.shift(); |
|||
|
|||
if (mode === undefined) mkdirp(p, cb) |
|||
else mkdirp(p, mode, cb) |
|||
|
|||
function cb (err) { |
|||
if (err) { |
|||
console.error(err.message); |
|||
process.exit(1); |
|||
} |
|||
else next(); |
|||
} |
|||
})(); |
|||
@ -1,42 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
|
|||
/** |
|||
* Script that will execute the downloaded phantomjs binary. stdio are |
|||
* forwarded to and from the child process. |
|||
* |
|||
* The following is for an ugly hack to avoid a problem where the installer |
|||
* finds the bin script npm creates during global installation. |
|||
* |
|||
* {NPM_INSTALL_MARKER} |
|||
*/ |
|||
|
|||
var path = require('path') |
|||
var spawn = require('child_process').spawn |
|||
|
|||
var binPath = require(path.join(__dirname, '..', 'lib', 'phantomjs')).path |
|||
|
|||
var args = process.argv.slice(2) |
|||
|
|||
// For Node 0.6 compatibility, pipe the streams manually, instead of using |
|||
// `{ stdio: 'inherit' }`. |
|||
var cp = spawn(binPath, args) |
|||
cp.stdout.pipe(process.stdout) |
|||
cp.stderr.pipe(process.stderr) |
|||
process.stdin.pipe(cp.stdin) |
|||
|
|||
cp.on('error', function (err) { |
|||
console.error('Error executing phantom at', binPath) |
|||
console.error(err.stack) |
|||
}) |
|||
|
|||
cp.on('exit', function(code){ |
|||
// Wait few ms for error to be printed. |
|||
setTimeout(function(){ |
|||
process.exit(code) |
|||
}, 20) |
|||
}); |
|||
|
|||
process.on('SIGTERM', function() { |
|||
cp.kill('SIGTERM') |
|||
process.exit(1) |
|||
}) |
|||
@ -1,243 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
// -*- mode: js -*- |
|||
// vim: set filetype=javascript : |
|||
// Copyright 2018 Joyent, Inc. All rights reserved. |
|||
|
|||
var dashdash = require('dashdash'); |
|||
var sshpk = require('../lib/index'); |
|||
var fs = require('fs'); |
|||
var path = require('path'); |
|||
var tty = require('tty'); |
|||
var readline = require('readline'); |
|||
var getPassword = require('getpass').getPass; |
|||
|
|||
var options = [ |
|||
{ |
|||
names: ['outformat', 't'], |
|||
type: 'string', |
|||
help: 'Output format' |
|||
}, |
|||
{ |
|||
names: ['informat', 'T'], |
|||
type: 'string', |
|||
help: 'Input format' |
|||
}, |
|||
{ |
|||
names: ['file', 'f'], |
|||
type: 'string', |
|||
help: 'Input file name (default stdin)' |
|||
}, |
|||
{ |
|||
names: ['out', 'o'], |
|||
type: 'string', |
|||
help: 'Output file name (default stdout)' |
|||
}, |
|||
{ |
|||
names: ['private', 'p'], |
|||
type: 'bool', |
|||
help: 'Produce a private key as output' |
|||
}, |
|||
{ |
|||
names: ['derive', 'd'], |
|||
type: 'string', |
|||
help: 'Output a new key derived from this one, with given algo' |
|||
}, |
|||
{ |
|||
names: ['identify', 'i'], |
|||
type: 'bool', |
|||
help: 'Print key metadata instead of converting' |
|||
}, |
|||
{ |
|||
names: ['fingerprint', 'F'], |
|||
type: 'bool', |
|||
help: 'Output key fingerprint' |
|||
}, |
|||
{ |
|||
names: ['hash', 'H'], |
|||
type: 'string', |
|||
help: 'Hash function to use for key fingeprint with -F' |
|||
}, |
|||
{ |
|||
names: ['spki', 's'], |
|||
type: 'bool', |
|||
help: 'With -F, generates an SPKI fingerprint instead of SSH' |
|||
}, |
|||
{ |
|||
names: ['comment', 'c'], |
|||
type: 'string', |
|||
help: 'Set key comment, if output format supports' |
|||
}, |
|||
{ |
|||
names: ['help', 'h'], |
|||
type: 'bool', |
|||
help: 'Shows this help text' |
|||
} |
|||
]; |
|||
|
|||
if (require.main === module) { |
|||
var parser = dashdash.createParser({ |
|||
options: options |
|||
}); |
|||
|
|||
try { |
|||
var opts = parser.parse(process.argv); |
|||
} catch (e) { |
|||
console.error('sshpk-conv: error: %s', e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
if (opts.help || opts._args.length > 1) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-conv: converts between SSH key formats\n'); |
|||
console.error(help); |
|||
console.error('\navailable key formats:'); |
|||
console.error(' - pem, pkcs1 eg id_rsa'); |
|||
console.error(' - ssh eg id_rsa.pub'); |
|||
console.error(' - pkcs8 format you want for openssl'); |
|||
console.error(' - openssh like output of ssh-keygen -o'); |
|||
console.error(' - rfc4253 raw OpenSSH wire format'); |
|||
console.error(' - dnssec dnssec-keygen format'); |
|||
console.error(' - putty PuTTY ppk format'); |
|||
console.error('\navailable fingerprint formats:'); |
|||
console.error(' - hex colon-separated hex for SSH'); |
|||
console.error(' straight hex for SPKI'); |
|||
console.error(' - base64 SHA256:* format from OpenSSH'); |
|||
process.exit(1); |
|||
} |
|||
|
|||
/* |
|||
* Key derivation can only be done on private keys, so use of the -d |
|||
* option necessarily implies -p. |
|||
*/ |
|||
if (opts.derive) |
|||
opts.private = true; |
|||
|
|||
var inFile = process.stdin; |
|||
var inFileName = 'stdin'; |
|||
|
|||
var inFilePath; |
|||
if (opts.file) { |
|||
inFilePath = opts.file; |
|||
} else if (opts._args.length === 1) { |
|||
inFilePath = opts._args[0]; |
|||
} |
|||
|
|||
if (inFilePath) |
|||
inFileName = path.basename(inFilePath); |
|||
|
|||
try { |
|||
if (inFilePath) { |
|||
fs.accessSync(inFilePath, fs.R_OK); |
|||
inFile = fs.createReadStream(inFilePath); |
|||
} |
|||
} catch (e) { |
|||
ifError(e, 'error opening input file'); |
|||
} |
|||
|
|||
var outFile = process.stdout; |
|||
|
|||
try { |
|||
if (opts.out && !opts.identify) { |
|||
fs.accessSync(path.dirname(opts.out), fs.W_OK); |
|||
outFile = fs.createWriteStream(opts.out); |
|||
} |
|||
} catch (e) { |
|||
ifError(e, 'error opening output file'); |
|||
} |
|||
|
|||
var bufs = []; |
|||
inFile.on('readable', function () { |
|||
var data; |
|||
while ((data = inFile.read())) |
|||
bufs.push(data); |
|||
}); |
|||
var parseOpts = {}; |
|||
parseOpts.filename = inFileName; |
|||
inFile.on('end', function processKey() { |
|||
var buf = Buffer.concat(bufs); |
|||
var fmt = 'auto'; |
|||
if (opts.informat) |
|||
fmt = opts.informat; |
|||
var f = sshpk.parseKey; |
|||
if (opts.private) |
|||
f = sshpk.parsePrivateKey; |
|||
try { |
|||
var key = f(buf, fmt, parseOpts); |
|||
} catch (e) { |
|||
if (e.name === 'KeyEncryptedError') { |
|||
getPassword(function (err, pw) { |
|||
if (err) |
|||
ifError(err); |
|||
parseOpts.passphrase = pw; |
|||
processKey(); |
|||
}); |
|||
return; |
|||
} |
|||
ifError(e); |
|||
} |
|||
|
|||
if (opts.derive) |
|||
key = key.derive(opts.derive); |
|||
|
|||
if (opts.comment) |
|||
key.comment = opts.comment; |
|||
|
|||
if (opts.identify) { |
|||
var kind = 'public'; |
|||
if (sshpk.PrivateKey.isPrivateKey(key)) |
|||
kind = 'private'; |
|||
console.log('%s: a %d bit %s %s key', inFileName, |
|||
key.size, key.type.toUpperCase(), kind); |
|||
if (key.type === 'ecdsa') |
|||
console.log('ECDSA curve: %s', key.curve); |
|||
if (key.comment) |
|||
console.log('Comment: %s', key.comment); |
|||
console.log('SHA256 fingerprint: ' + |
|||
key.fingerprint('sha256').toString()); |
|||
console.log('MD5 fingerprint: ' + |
|||
key.fingerprint('md5').toString()); |
|||
console.log('SPKI-SHA256 fingerprint: ' + |
|||
key.fingerprint('sha256', 'spki').toString()); |
|||
process.exit(0); |
|||
return; |
|||
} |
|||
|
|||
if (opts.fingerprint) { |
|||
var hash = opts.hash; |
|||
var type = opts.spki ? 'spki' : 'ssh'; |
|||
var format = opts.outformat; |
|||
var fp = key.fingerprint(hash, type).toString(format); |
|||
outFile.write(fp); |
|||
outFile.write('\n'); |
|||
outFile.once('drain', function () { |
|||
process.exit(0); |
|||
}); |
|||
return; |
|||
} |
|||
|
|||
fmt = undefined; |
|||
if (opts.outformat) |
|||
fmt = opts.outformat; |
|||
outFile.write(key.toBuffer(fmt)); |
|||
if (fmt === 'ssh' || |
|||
(!opts.private && fmt === undefined)) |
|||
outFile.write('\n'); |
|||
outFile.once('drain', function () { |
|||
process.exit(0); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
function ifError(e, txt) { |
|||
if (txt) |
|||
txt = txt + ': '; |
|||
else |
|||
txt = ''; |
|||
console.error('sshpk-conv: ' + txt + e.name + ': ' + e.message); |
|||
if (process.env['DEBUG'] || process.env['V']) { |
|||
console.error(e.stack); |
|||
if (e.innerErr) |
|||
console.error(e.innerErr.stack); |
|||
} |
|||
process.exit(1); |
|||
} |
|||
@ -1,191 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
// -*- mode: js -*- |
|||
// vim: set filetype=javascript : |
|||
// Copyright 2015 Joyent, Inc. All rights reserved. |
|||
|
|||
var dashdash = require('dashdash'); |
|||
var sshpk = require('../lib/index'); |
|||
var fs = require('fs'); |
|||
var path = require('path'); |
|||
var getPassword = require('getpass').getPass; |
|||
|
|||
var options = [ |
|||
{ |
|||
names: ['hash', 'H'], |
|||
type: 'string', |
|||
help: 'Hash algorithm (sha1, sha256, sha384, sha512)' |
|||
}, |
|||
{ |
|||
names: ['verbose', 'v'], |
|||
type: 'bool', |
|||
help: 'Display verbose info about key and hash used' |
|||
}, |
|||
{ |
|||
names: ['identity', 'i'], |
|||
type: 'string', |
|||
help: 'Path to key to use' |
|||
}, |
|||
{ |
|||
names: ['file', 'f'], |
|||
type: 'string', |
|||
help: 'Input filename' |
|||
}, |
|||
{ |
|||
names: ['out', 'o'], |
|||
type: 'string', |
|||
help: 'Output filename' |
|||
}, |
|||
{ |
|||
names: ['format', 't'], |
|||
type: 'string', |
|||
help: 'Signature format (asn1, ssh, raw)' |
|||
}, |
|||
{ |
|||
names: ['binary', 'b'], |
|||
type: 'bool', |
|||
help: 'Output raw binary instead of base64' |
|||
}, |
|||
{ |
|||
names: ['help', 'h'], |
|||
type: 'bool', |
|||
help: 'Shows this help text' |
|||
} |
|||
]; |
|||
|
|||
var parseOpts = {}; |
|||
|
|||
if (require.main === module) { |
|||
var parser = dashdash.createParser({ |
|||
options: options |
|||
}); |
|||
|
|||
try { |
|||
var opts = parser.parse(process.argv); |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error: %s', e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
if (opts.help || opts._args.length > 1) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-sign: sign data using an SSH key\n'); |
|||
console.error(help); |
|||
process.exit(1); |
|||
} |
|||
|
|||
if (!opts.identity) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-sign: the -i or --identity option ' + |
|||
'is required\n'); |
|||
console.error(help); |
|||
process.exit(1); |
|||
} |
|||
|
|||
var keyData = fs.readFileSync(opts.identity); |
|||
parseOpts.filename = opts.identity; |
|||
|
|||
run(); |
|||
} |
|||
|
|||
function run() { |
|||
var key; |
|||
try { |
|||
key = sshpk.parsePrivateKey(keyData, 'auto', parseOpts); |
|||
} catch (e) { |
|||
if (e.name === 'KeyEncryptedError') { |
|||
getPassword(function (err, pw) { |
|||
parseOpts.passphrase = pw; |
|||
run(); |
|||
}); |
|||
return; |
|||
} |
|||
console.error('sshpk-sign: error loading private key "' + |
|||
opts.identity + '": ' + e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
var hash = opts.hash || key.defaultHashAlgorithm(); |
|||
|
|||
var signer; |
|||
try { |
|||
signer = key.createSign(hash); |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error creating signer: ' + |
|||
e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
if (opts.verbose) { |
|||
console.error('sshpk-sign: using %s-%s with a %d bit key', |
|||
key.type, hash, key.size); |
|||
} |
|||
|
|||
var inFile = process.stdin; |
|||
var inFileName = 'stdin'; |
|||
|
|||
var inFilePath; |
|||
if (opts.file) { |
|||
inFilePath = opts.file; |
|||
} else if (opts._args.length === 1) { |
|||
inFilePath = opts._args[0]; |
|||
} |
|||
|
|||
if (inFilePath) |
|||
inFileName = path.basename(inFilePath); |
|||
|
|||
try { |
|||
if (inFilePath) { |
|||
fs.accessSync(inFilePath, fs.R_OK); |
|||
inFile = fs.createReadStream(inFilePath); |
|||
} |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error opening input file' + |
|||
': ' + e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
var outFile = process.stdout; |
|||
|
|||
try { |
|||
if (opts.out && !opts.identify) { |
|||
fs.accessSync(path.dirname(opts.out), fs.W_OK); |
|||
outFile = fs.createWriteStream(opts.out); |
|||
} |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error opening output file' + |
|||
': ' + e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
inFile.pipe(signer); |
|||
inFile.on('end', function () { |
|||
var sig; |
|||
try { |
|||
sig = signer.sign(); |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error signing data: ' + |
|||
e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
var fmt = opts.format || 'asn1'; |
|||
var output; |
|||
try { |
|||
output = sig.toBuffer(fmt); |
|||
if (!opts.binary) |
|||
output = output.toString('base64'); |
|||
} catch (e) { |
|||
console.error('sshpk-sign: error converting signature' + |
|||
' to ' + fmt + ' format: ' + e.name + ': ' + |
|||
e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
outFile.write(output); |
|||
if (!opts.binary) |
|||
outFile.write('\n'); |
|||
outFile.once('drain', function () { |
|||
process.exit(0); |
|||
}); |
|||
}); |
|||
} |
|||
@ -1,167 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
// -*- mode: js -*- |
|||
// vim: set filetype=javascript : |
|||
// Copyright 2015 Joyent, Inc. All rights reserved. |
|||
|
|||
var dashdash = require('dashdash'); |
|||
var sshpk = require('../lib/index'); |
|||
var fs = require('fs'); |
|||
var path = require('path'); |
|||
var Buffer = require('safer-buffer').Buffer; |
|||
|
|||
var options = [ |
|||
{ |
|||
names: ['hash', 'H'], |
|||
type: 'string', |
|||
help: 'Hash algorithm (sha1, sha256, sha384, sha512)' |
|||
}, |
|||
{ |
|||
names: ['verbose', 'v'], |
|||
type: 'bool', |
|||
help: 'Display verbose info about key and hash used' |
|||
}, |
|||
{ |
|||
names: ['identity', 'i'], |
|||
type: 'string', |
|||
help: 'Path to (public) key to use' |
|||
}, |
|||
{ |
|||
names: ['file', 'f'], |
|||
type: 'string', |
|||
help: 'Input filename' |
|||
}, |
|||
{ |
|||
names: ['format', 't'], |
|||
type: 'string', |
|||
help: 'Signature format (asn1, ssh, raw)' |
|||
}, |
|||
{ |
|||
names: ['signature', 's'], |
|||
type: 'string', |
|||
help: 'base64-encoded signature data' |
|||
}, |
|||
{ |
|||
names: ['help', 'h'], |
|||
type: 'bool', |
|||
help: 'Shows this help text' |
|||
} |
|||
]; |
|||
|
|||
if (require.main === module) { |
|||
var parser = dashdash.createParser({ |
|||
options: options |
|||
}); |
|||
|
|||
try { |
|||
var opts = parser.parse(process.argv); |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error: %s', e.message); |
|||
process.exit(3); |
|||
} |
|||
|
|||
if (opts.help || opts._args.length > 1) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-verify: sign data using an SSH key\n'); |
|||
console.error(help); |
|||
process.exit(3); |
|||
} |
|||
|
|||
if (!opts.identity) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-verify: the -i or --identity option ' + |
|||
'is required\n'); |
|||
console.error(help); |
|||
process.exit(3); |
|||
} |
|||
|
|||
if (!opts.signature) { |
|||
var help = parser.help({}).trimRight(); |
|||
console.error('sshpk-verify: the -s or --signature option ' + |
|||
'is required\n'); |
|||
console.error(help); |
|||
process.exit(3); |
|||
} |
|||
|
|||
var keyData = fs.readFileSync(opts.identity); |
|||
|
|||
var key; |
|||
try { |
|||
key = sshpk.parseKey(keyData); |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error loading key "' + |
|||
opts.identity + '": ' + e.name + ': ' + e.message); |
|||
process.exit(2); |
|||
} |
|||
|
|||
var fmt = opts.format || 'asn1'; |
|||
var sigData = Buffer.from(opts.signature, 'base64'); |
|||
|
|||
var sig; |
|||
try { |
|||
sig = sshpk.parseSignature(sigData, key.type, fmt); |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error parsing signature: ' + |
|||
e.name + ': ' + e.message); |
|||
process.exit(2); |
|||
} |
|||
|
|||
var hash = opts.hash || key.defaultHashAlgorithm(); |
|||
|
|||
var verifier; |
|||
try { |
|||
verifier = key.createVerify(hash); |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error creating verifier: ' + |
|||
e.name + ': ' + e.message); |
|||
process.exit(2); |
|||
} |
|||
|
|||
if (opts.verbose) { |
|||
console.error('sshpk-verify: using %s-%s with a %d bit key', |
|||
key.type, hash, key.size); |
|||
} |
|||
|
|||
var inFile = process.stdin; |
|||
var inFileName = 'stdin'; |
|||
|
|||
var inFilePath; |
|||
if (opts.file) { |
|||
inFilePath = opts.file; |
|||
} else if (opts._args.length === 1) { |
|||
inFilePath = opts._args[0]; |
|||
} |
|||
|
|||
if (inFilePath) |
|||
inFileName = path.basename(inFilePath); |
|||
|
|||
try { |
|||
if (inFilePath) { |
|||
fs.accessSync(inFilePath, fs.R_OK); |
|||
inFile = fs.createReadStream(inFilePath); |
|||
} |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error opening input file' + |
|||
': ' + e.name + ': ' + e.message); |
|||
process.exit(2); |
|||
} |
|||
|
|||
inFile.pipe(verifier); |
|||
inFile.on('end', function () { |
|||
var ret; |
|||
try { |
|||
ret = verifier.verify(sig); |
|||
} catch (e) { |
|||
console.error('sshpk-verify: error verifying data: ' + |
|||
e.name + ': ' + e.message); |
|||
process.exit(1); |
|||
} |
|||
|
|||
if (ret) { |
|||
console.error('OK'); |
|||
process.exit(0); |
|||
} |
|||
|
|||
console.error('NOT OK'); |
|||
process.exit(1); |
|||
}); |
|||
} |
|||
@ -1,65 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
var assert = require('assert'); |
|||
|
|||
function usage() { |
|||
console.log('Usage:'); |
|||
console.log(' uuid'); |
|||
console.log(' uuid v1'); |
|||
console.log(' uuid v3 <name> <namespace uuid>'); |
|||
console.log(' uuid v4'); |
|||
console.log(' uuid v5 <name> <namespace uuid>'); |
|||
console.log(' uuid --help'); |
|||
console.log('\nNote: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC4122'); |
|||
} |
|||
|
|||
var args = process.argv.slice(2); |
|||
|
|||
if (args.indexOf('--help') >= 0) { |
|||
usage(); |
|||
process.exit(0); |
|||
} |
|||
var version = args.shift() || 'v4'; |
|||
|
|||
switch (version) { |
|||
case 'v1': |
|||
var uuidV1 = require('../v1'); |
|||
console.log(uuidV1()); |
|||
break; |
|||
|
|||
case 'v3': |
|||
var uuidV3 = require('../v3'); |
|||
|
|||
var name = args.shift(); |
|||
var namespace = args.shift(); |
|||
assert(name != null, 'v3 name not specified'); |
|||
assert(namespace != null, 'v3 namespace not specified'); |
|||
|
|||
if (namespace == 'URL') namespace = uuidV3.URL; |
|||
if (namespace == 'DNS') namespace = uuidV3.DNS; |
|||
|
|||
console.log(uuidV3(name, namespace)); |
|||
break; |
|||
|
|||
case 'v4': |
|||
var uuidV4 = require('../v4'); |
|||
console.log(uuidV4()); |
|||
break; |
|||
|
|||
case 'v5': |
|||
var uuidV5 = require('../v5'); |
|||
|
|||
var name = args.shift(); |
|||
var namespace = args.shift(); |
|||
assert(name != null, 'v5 name not specified'); |
|||
assert(namespace != null, 'v5 namespace not specified'); |
|||
|
|||
if (namespace == 'URL') namespace = uuidV5.URL; |
|||
if (namespace == 'DNS') namespace = uuidV5.DNS; |
|||
|
|||
console.log(uuidV5(name, namespace)); |
|||
break; |
|||
|
|||
default: |
|||
usage(); |
|||
process.exit(1); |
|||
} |
|||
@ -1,52 +0,0 @@ |
|||
#!/usr/bin/env node |
|||
var which = require("../") |
|||
if (process.argv.length < 3) |
|||
usage() |
|||
|
|||
function usage () { |
|||
console.error('usage: which [-as] program ...') |
|||
process.exit(1) |
|||
} |
|||
|
|||
var all = false |
|||
var silent = false |
|||
var dashdash = false |
|||
var args = process.argv.slice(2).filter(function (arg) { |
|||
if (dashdash || !/^-/.test(arg)) |
|||
return true |
|||
|
|||
if (arg === '--') { |
|||
dashdash = true |
|||
return false |
|||
} |
|||
|
|||
var flags = arg.substr(1).split('') |
|||
for (var f = 0; f < flags.length; f++) { |
|||
var flag = flags[f] |
|||
switch (flag) { |
|||
case 's': |
|||
silent = true |
|||
break |
|||
case 'a': |
|||
all = true |
|||
break |
|||
default: |
|||
console.error('which: illegal option -- ' + flag) |
|||
usage() |
|||
} |
|||
} |
|||
return false |
|||
}) |
|||
|
|||
process.exit(args.reduce(function (pv, current) { |
|||
try { |
|||
var f = which.sync(current, { all: all }) |
|||
if (all) |
|||
f = f.join('\n') |
|||
if (!silent) |
|||
console.log(f) |
|||
return pv; |
|||
} catch (e) { |
|||
return 1; |
|||
} |
|||
}, 0)) |
|||
@ -1,20 +0,0 @@ |
|||
var Ajv = require('ajv'); |
|||
var ajv = new Ajv({allErrors: true}); |
|||
|
|||
var schema = { |
|||
"properties": { |
|||
"foo": { "type": "string" }, |
|||
"bar": { "type": "number", "maximum": 3 } |
|||
} |
|||
}; |
|||
|
|||
var validate = ajv.compile(schema); |
|||
|
|||
test({"foo": "abc", "bar": 2}); |
|||
test({"foo": 2, "bar": 4}); |
|||
|
|||
function test(data) { |
|||
var valid = validate(data); |
|||
if (valid) console.log('Valid!'); |
|||
else console.log('Invalid: ' + ajv.errorsText(validate.errors)); |
|||
} |
|||
@ -1,22 +0,0 @@ |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-2017 Evgeny Poberezkin |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in all |
|||
copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
SOFTWARE. |
|||
|
|||
File diff suppressed because it is too large
@ -1,397 +0,0 @@ |
|||
declare var ajv: { |
|||
(options?: ajv.Options): ajv.Ajv; |
|||
new(options?: ajv.Options): ajv.Ajv; |
|||
ValidationError: typeof AjvErrors.ValidationError; |
|||
MissingRefError: typeof AjvErrors.MissingRefError; |
|||
$dataMetaSchema: object; |
|||
} |
|||
|
|||
declare namespace AjvErrors { |
|||
class ValidationError extends Error { |
|||
constructor(errors: Array<ajv.ErrorObject>); |
|||
|
|||
message: string; |
|||
errors: Array<ajv.ErrorObject>; |
|||
ajv: true; |
|||
validation: true; |
|||
} |
|||
|
|||
class MissingRefError extends Error { |
|||
constructor(baseId: string, ref: string, message?: string); |
|||
static message: (baseId: string, ref: string) => string; |
|||
|
|||
message: string; |
|||
missingRef: string; |
|||
missingSchema: string; |
|||
} |
|||
} |
|||
|
|||
declare namespace ajv { |
|||
type ValidationError = AjvErrors.ValidationError; |
|||
|
|||
type MissingRefError = AjvErrors.MissingRefError; |
|||
|
|||
interface Ajv { |
|||
/** |
|||
* Validate data using schema |
|||
* Schema will be compiled and cached (using serialized JSON as key, [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize by default).
|
|||
* @param {string|object|Boolean} schemaKeyRef key, ref or schema object |
|||
* @param {Any} data to be validated |
|||
* @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`). |
|||
*/ |
|||
validate(schemaKeyRef: object | string | boolean, data: any): boolean | PromiseLike<any>; |
|||
/** |
|||
* Create validating function for passed schema. |
|||
* @param {object|Boolean} schema schema object |
|||
* @return {Function} validating function |
|||
*/ |
|||
compile(schema: object | boolean): ValidateFunction; |
|||
/** |
|||
* Creates validating function for passed schema with asynchronous loading of missing schemas. |
|||
* `loadSchema` option should be a function that accepts schema uri and node-style callback. |
|||
* @this Ajv |
|||
* @param {object|Boolean} schema schema object |
|||
* @param {Boolean} meta optional true to compile meta-schema; this parameter can be skipped |
|||
* @param {Function} callback optional node-style callback, it is always called with 2 parameters: error (or null) and validating function. |
|||
* @return {PromiseLike<ValidateFunction>} validating function |
|||
*/ |
|||
compileAsync(schema: object | boolean, meta?: Boolean, callback?: (err: Error, validate: ValidateFunction) => any): PromiseLike<ValidateFunction>; |
|||
/** |
|||
* Adds schema to the instance. |
|||
* @param {object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored. |
|||
* @param {string} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
addSchema(schema: Array<object> | object, key?: string): Ajv; |
|||
/** |
|||
* Add schema that will be used to validate other schemas |
|||
* options in META_IGNORE_OPTIONS are alway set to false |
|||
* @param {object} schema schema object |
|||
* @param {string} key optional schema key |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
addMetaSchema(schema: object, key?: string): Ajv; |
|||
/** |
|||
* Validate schema |
|||
* @param {object|Boolean} schema schema to validate |
|||
* @return {Boolean} true if schema is valid |
|||
*/ |
|||
validateSchema(schema: object | boolean): boolean; |
|||
/** |
|||
* Get compiled schema from the instance by `key` or `ref`. |
|||
* @param {string} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id). |
|||
* @return {Function} schema validating function (with property `schema`). Returns undefined if keyRef can't be resolved to an existing schema. |
|||
*/ |
|||
getSchema(keyRef: string): ValidateFunction | undefined; |
|||
/** |
|||
* Remove cached schema(s). |
|||
* If no parameter is passed all schemas but meta-schemas are removed. |
|||
* If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. |
|||
* Even if schema is referenced by other schemas it still can be removed as other schemas have local references. |
|||
* @param {string|object|RegExp|Boolean} schemaKeyRef key, ref, pattern to match key/ref or schema object |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
removeSchema(schemaKeyRef?: object | string | RegExp | boolean): Ajv; |
|||
/** |
|||
* Add custom format |
|||
* @param {string} name format name |
|||
* @param {string|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid) |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
addFormat(name: string, format: FormatValidator | FormatDefinition): Ajv; |
|||
/** |
|||
* Define custom keyword |
|||
* @this Ajv |
|||
* @param {string} keyword custom keyword, should be a valid identifier, should be different from all standard, custom and macro keywords. |
|||
* @param {object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
addKeyword(keyword: string, definition: KeywordDefinition): Ajv; |
|||
/** |
|||
* Get keyword definition |
|||
* @this Ajv |
|||
* @param {string} keyword pre-defined or custom keyword. |
|||
* @return {object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise. |
|||
*/ |
|||
getKeyword(keyword: string): object | boolean; |
|||
/** |
|||
* Remove keyword |
|||
* @this Ajv |
|||
* @param {string} keyword pre-defined or custom keyword. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
removeKeyword(keyword: string): Ajv; |
|||
/** |
|||
* Validate keyword |
|||
* @this Ajv |
|||
* @param {object} definition keyword definition object |
|||
* @param {boolean} throwError true to throw exception if definition is invalid |
|||
* @return {boolean} validation result |
|||
*/ |
|||
validateKeyword(definition: KeywordDefinition, throwError: boolean): boolean; |
|||
/** |
|||
* Convert array of error message objects to string |
|||
* @param {Array<object>} errors optional array of validation errors, if not passed errors from the instance are used. |
|||
* @param {object} options optional options with properties `separator` and `dataVar`. |
|||
* @return {string} human readable string with all errors descriptions |
|||
*/ |
|||
errorsText(errors?: Array<ErrorObject> | null, options?: ErrorsTextOptions): string; |
|||
errors?: Array<ErrorObject> | null; |
|||
_opts: Options; |
|||
} |
|||
|
|||
interface CustomLogger { |
|||
log(...args: any[]): any; |
|||
warn(...args: any[]): any; |
|||
error(...args: any[]): any; |
|||
} |
|||
|
|||
interface ValidateFunction { |
|||
( |
|||
data: any, |
|||
dataPath?: string, |
|||
parentData?: object | Array<any>, |
|||
parentDataProperty?: string | number, |
|||
rootData?: object | Array<any> |
|||
): boolean | PromiseLike<any>; |
|||
schema?: object | boolean; |
|||
errors?: null | Array<ErrorObject>; |
|||
refs?: object; |
|||
refVal?: Array<any>; |
|||
root?: ValidateFunction | object; |
|||
$async?: true; |
|||
source?: object; |
|||
} |
|||
|
|||
interface Options { |
|||
$data?: boolean; |
|||
allErrors?: boolean; |
|||
verbose?: boolean; |
|||
jsonPointers?: boolean; |
|||
uniqueItems?: boolean; |
|||
unicode?: boolean; |
|||
format?: false | string; |
|||
formats?: object; |
|||
keywords?: object; |
|||
unknownFormats?: true | string[] | 'ignore'; |
|||
schemas?: Array<object> | object; |
|||
schemaId?: '$id' | 'id' | 'auto'; |
|||
missingRefs?: true | 'ignore' | 'fail'; |
|||
extendRefs?: true | 'ignore' | 'fail'; |
|||
loadSchema?: (uri: string, cb?: (err: Error, schema: object) => void) => PromiseLike<object | boolean>; |
|||
removeAdditional?: boolean | 'all' | 'failing'; |
|||
useDefaults?: boolean | 'empty' | 'shared'; |
|||
coerceTypes?: boolean | 'array'; |
|||
strictDefaults?: boolean | 'log'; |
|||
strictKeywords?: boolean | 'log'; |
|||
strictNumbers?: boolean; |
|||
async?: boolean | string; |
|||
transpile?: string | ((code: string) => string); |
|||
meta?: boolean | object; |
|||
validateSchema?: boolean | 'log'; |
|||
addUsedSchema?: boolean; |
|||
inlineRefs?: boolean | number; |
|||
passContext?: boolean; |
|||
loopRequired?: number; |
|||
ownProperties?: boolean; |
|||
multipleOfPrecision?: boolean | number; |
|||
errorDataPath?: string, |
|||
messages?: boolean; |
|||
sourceCode?: boolean; |
|||
processCode?: (code: string, schema: object) => string; |
|||
cache?: object; |
|||
logger?: CustomLogger | false; |
|||
nullable?: boolean; |
|||
serialize?: ((schema: object | boolean) => any) | false; |
|||
} |
|||
|
|||
type FormatValidator = string | RegExp | ((data: string) => boolean | PromiseLike<any>); |
|||
type NumberFormatValidator = ((data: number) => boolean | PromiseLike<any>); |
|||
|
|||
interface NumberFormatDefinition { |
|||
type: "number", |
|||
validate: NumberFormatValidator; |
|||
compare?: (data1: number, data2: number) => number; |
|||
async?: boolean; |
|||
} |
|||
|
|||
interface StringFormatDefinition { |
|||
type?: "string", |
|||
validate: FormatValidator; |
|||
compare?: (data1: string, data2: string) => number; |
|||
async?: boolean; |
|||
} |
|||
|
|||
type FormatDefinition = NumberFormatDefinition | StringFormatDefinition; |
|||
|
|||
interface KeywordDefinition { |
|||
type?: string | Array<string>; |
|||
async?: boolean; |
|||
$data?: boolean; |
|||
errors?: boolean | string; |
|||
metaSchema?: object; |
|||
// schema: false makes validate not to expect schema (ValidateFunction)
|
|||
schema?: boolean; |
|||
statements?: boolean; |
|||
dependencies?: Array<string>; |
|||
modifying?: boolean; |
|||
valid?: boolean; |
|||
// one and only one of the following properties should be present
|
|||
validate?: SchemaValidateFunction | ValidateFunction; |
|||
compile?: (schema: any, parentSchema: object, it: CompilationContext) => ValidateFunction; |
|||
macro?: (schema: any, parentSchema: object, it: CompilationContext) => object | boolean; |
|||
inline?: (it: CompilationContext, keyword: string, schema: any, parentSchema: object) => string; |
|||
} |
|||
|
|||
interface CompilationContext { |
|||
level: number; |
|||
dataLevel: number; |
|||
dataPathArr: string[]; |
|||
schema: any; |
|||
schemaPath: string; |
|||
baseId: string; |
|||
async: boolean; |
|||
opts: Options; |
|||
formats: { |
|||
[index: string]: FormatDefinition | undefined; |
|||
}; |
|||
keywords: { |
|||
[index: string]: KeywordDefinition | undefined; |
|||
}; |
|||
compositeRule: boolean; |
|||
validate: (schema: object) => boolean; |
|||
util: { |
|||
copy(obj: any, target?: any): any; |
|||
toHash(source: string[]): { [index: string]: true | undefined }; |
|||
equal(obj: any, target: any): boolean; |
|||
getProperty(str: string): string; |
|||
schemaHasRules(schema: object, rules: any): string; |
|||
escapeQuotes(str: string): string; |
|||
toQuotedString(str: string): string; |
|||
getData(jsonPointer: string, dataLevel: number, paths: string[]): string; |
|||
escapeJsonPointer(str: string): string; |
|||
unescapeJsonPointer(str: string): string; |
|||
escapeFragment(str: string): string; |
|||
unescapeFragment(str: string): string; |
|||
}; |
|||
self: Ajv; |
|||
} |
|||
|
|||
interface SchemaValidateFunction { |
|||
( |
|||
schema: any, |
|||
data: any, |
|||
parentSchema?: object, |
|||
dataPath?: string, |
|||
parentData?: object | Array<any>, |
|||
parentDataProperty?: string | number, |
|||
rootData?: object | Array<any> |
|||
): boolean | PromiseLike<any>; |
|||
errors?: Array<ErrorObject>; |
|||
} |
|||
|
|||
interface ErrorsTextOptions { |
|||
separator?: string; |
|||
dataVar?: string; |
|||
} |
|||
|
|||
interface ErrorObject { |
|||
keyword: string; |
|||
dataPath: string; |
|||
schemaPath: string; |
|||
params: ErrorParameters; |
|||
// Added to validation errors of propertyNames keyword schema
|
|||
propertyName?: string; |
|||
// Excluded if messages set to false.
|
|||
message?: string; |
|||
// These are added with the `verbose` option.
|
|||
schema?: any; |
|||
parentSchema?: object; |
|||
data?: any; |
|||
} |
|||
|
|||
type ErrorParameters = RefParams | LimitParams | AdditionalPropertiesParams | |
|||
DependenciesParams | FormatParams | ComparisonParams | |
|||
MultipleOfParams | PatternParams | RequiredParams | |
|||
TypeParams | UniqueItemsParams | CustomParams | |
|||
PatternRequiredParams | PropertyNamesParams | |
|||
IfParams | SwitchParams | NoParams | EnumParams; |
|||
|
|||
interface RefParams { |
|||
ref: string; |
|||
} |
|||
|
|||
interface LimitParams { |
|||
limit: number; |
|||
} |
|||
|
|||
interface AdditionalPropertiesParams { |
|||
additionalProperty: string; |
|||
} |
|||
|
|||
interface DependenciesParams { |
|||
property: string; |
|||
missingProperty: string; |
|||
depsCount: number; |
|||
deps: string; |
|||
} |
|||
|
|||
interface FormatParams { |
|||
format: string |
|||
} |
|||
|
|||
interface ComparisonParams { |
|||
comparison: string; |
|||
limit: number | string; |
|||
exclusive: boolean; |
|||
} |
|||
|
|||
interface MultipleOfParams { |
|||
multipleOf: number; |
|||
} |
|||
|
|||
interface PatternParams { |
|||
pattern: string; |
|||
} |
|||
|
|||
interface RequiredParams { |
|||
missingProperty: string; |
|||
} |
|||
|
|||
interface TypeParams { |
|||
type: string; |
|||
} |
|||
|
|||
interface UniqueItemsParams { |
|||
i: number; |
|||
j: number; |
|||
} |
|||
|
|||
interface CustomParams { |
|||
keyword: string; |
|||
} |
|||
|
|||
interface PatternRequiredParams { |
|||
missingPattern: string; |
|||
} |
|||
|
|||
interface PropertyNamesParams { |
|||
propertyName: string; |
|||
} |
|||
|
|||
interface IfParams { |
|||
failingKeyword: string; |
|||
} |
|||
|
|||
interface SwitchParams { |
|||
caseIndex: number; |
|||
} |
|||
|
|||
interface NoParams { } |
|||
|
|||
interface EnumParams { |
|||
allowedValues: Array<any>; |
|||
} |
|||
} |
|||
|
|||
export = ajv; |
|||
@ -1,506 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var compileSchema = require('./compile') |
|||
, resolve = require('./compile/resolve') |
|||
, Cache = require('./cache') |
|||
, SchemaObject = require('./compile/schema_obj') |
|||
, stableStringify = require('fast-json-stable-stringify') |
|||
, formats = require('./compile/formats') |
|||
, rules = require('./compile/rules') |
|||
, $dataMetaSchema = require('./data') |
|||
, util = require('./compile/util'); |
|||
|
|||
module.exports = Ajv; |
|||
|
|||
Ajv.prototype.validate = validate; |
|||
Ajv.prototype.compile = compile; |
|||
Ajv.prototype.addSchema = addSchema; |
|||
Ajv.prototype.addMetaSchema = addMetaSchema; |
|||
Ajv.prototype.validateSchema = validateSchema; |
|||
Ajv.prototype.getSchema = getSchema; |
|||
Ajv.prototype.removeSchema = removeSchema; |
|||
Ajv.prototype.addFormat = addFormat; |
|||
Ajv.prototype.errorsText = errorsText; |
|||
|
|||
Ajv.prototype._addSchema = _addSchema; |
|||
Ajv.prototype._compile = _compile; |
|||
|
|||
Ajv.prototype.compileAsync = require('./compile/async'); |
|||
var customKeyword = require('./keyword'); |
|||
Ajv.prototype.addKeyword = customKeyword.add; |
|||
Ajv.prototype.getKeyword = customKeyword.get; |
|||
Ajv.prototype.removeKeyword = customKeyword.remove; |
|||
Ajv.prototype.validateKeyword = customKeyword.validate; |
|||
|
|||
var errorClasses = require('./compile/error_classes'); |
|||
Ajv.ValidationError = errorClasses.Validation; |
|||
Ajv.MissingRefError = errorClasses.MissingRef; |
|||
Ajv.$dataMetaSchema = $dataMetaSchema; |
|||
|
|||
var META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema'; |
|||
|
|||
var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ]; |
|||
var META_SUPPORT_DATA = ['/properties']; |
|||
|
|||
/** |
|||
* Creates validator instance. |
|||
* Usage: `Ajv(opts)` |
|||
* @param {Object} opts optional options |
|||
* @return {Object} ajv instance |
|||
*/ |
|||
function Ajv(opts) { |
|||
if (!(this instanceof Ajv)) return new Ajv(opts); |
|||
opts = this._opts = util.copy(opts) || {}; |
|||
setLogger(this); |
|||
this._schemas = {}; |
|||
this._refs = {}; |
|||
this._fragments = {}; |
|||
this._formats = formats(opts.format); |
|||
|
|||
this._cache = opts.cache || new Cache; |
|||
this._loadingSchemas = {}; |
|||
this._compilations = []; |
|||
this.RULES = rules(); |
|||
this._getId = chooseGetId(opts); |
|||
|
|||
opts.loopRequired = opts.loopRequired || Infinity; |
|||
if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true; |
|||
if (opts.serialize === undefined) opts.serialize = stableStringify; |
|||
this._metaOpts = getMetaSchemaOptions(this); |
|||
|
|||
if (opts.formats) addInitialFormats(this); |
|||
if (opts.keywords) addInitialKeywords(this); |
|||
addDefaultMetaSchema(this); |
|||
if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta); |
|||
if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}}); |
|||
addInitialSchemas(this); |
|||
} |
|||
|
|||
|
|||
|
|||
/** |
|||
* Validate data using schema |
|||
* Schema will be compiled and cached (using serialized JSON as key. [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize.
|
|||
* @this Ajv |
|||
* @param {String|Object} schemaKeyRef key, ref or schema object |
|||
* @param {Any} data to be validated |
|||
* @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`). |
|||
*/ |
|||
function validate(schemaKeyRef, data) { |
|||
var v; |
|||
if (typeof schemaKeyRef == 'string') { |
|||
v = this.getSchema(schemaKeyRef); |
|||
if (!v) throw new Error('no schema with key or ref "' + schemaKeyRef + '"'); |
|||
} else { |
|||
var schemaObj = this._addSchema(schemaKeyRef); |
|||
v = schemaObj.validate || this._compile(schemaObj); |
|||
} |
|||
|
|||
var valid = v(data); |
|||
if (v.$async !== true) this.errors = v.errors; |
|||
return valid; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Create validating function for passed schema. |
|||
* @this Ajv |
|||
* @param {Object} schema schema object |
|||
* @param {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords. |
|||
* @return {Function} validating function |
|||
*/ |
|||
function compile(schema, _meta) { |
|||
var schemaObj = this._addSchema(schema, undefined, _meta); |
|||
return schemaObj.validate || this._compile(schemaObj); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Adds schema to the instance. |
|||
* @this Ajv |
|||
* @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored. |
|||
* @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`. |
|||
* @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead. |
|||
* @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function addSchema(schema, key, _skipValidation, _meta) { |
|||
if (Array.isArray(schema)){ |
|||
for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta); |
|||
return this; |
|||
} |
|||
var id = this._getId(schema); |
|||
if (id !== undefined && typeof id != 'string') |
|||
throw new Error('schema id must be string'); |
|||
key = resolve.normalizeId(key || id); |
|||
checkUnique(this, key); |
|||
this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true); |
|||
return this; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Add schema that will be used to validate other schemas |
|||
* options in META_IGNORE_OPTIONS are alway set to false |
|||
* @this Ajv |
|||
* @param {Object} schema schema object |
|||
* @param {String} key optional schema key |
|||
* @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function addMetaSchema(schema, key, skipValidation) { |
|||
this.addSchema(schema, key, skipValidation, true); |
|||
return this; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Validate schema |
|||
* @this Ajv |
|||
* @param {Object} schema schema to validate |
|||
* @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid |
|||
* @return {Boolean} true if schema is valid |
|||
*/ |
|||
function validateSchema(schema, throwOrLogError) { |
|||
var $schema = schema.$schema; |
|||
if ($schema !== undefined && typeof $schema != 'string') |
|||
throw new Error('$schema must be a string'); |
|||
$schema = $schema || this._opts.defaultMeta || defaultMeta(this); |
|||
if (!$schema) { |
|||
this.logger.warn('meta-schema not available'); |
|||
this.errors = null; |
|||
return true; |
|||
} |
|||
var valid = this.validate($schema, schema); |
|||
if (!valid && throwOrLogError) { |
|||
var message = 'schema is invalid: ' + this.errorsText(); |
|||
if (this._opts.validateSchema == 'log') this.logger.error(message); |
|||
else throw new Error(message); |
|||
} |
|||
return valid; |
|||
} |
|||
|
|||
|
|||
function defaultMeta(self) { |
|||
var meta = self._opts.meta; |
|||
self._opts.defaultMeta = typeof meta == 'object' |
|||
? self._getId(meta) || meta |
|||
: self.getSchema(META_SCHEMA_ID) |
|||
? META_SCHEMA_ID |
|||
: undefined; |
|||
return self._opts.defaultMeta; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Get compiled schema from the instance by `key` or `ref`. |
|||
* @this Ajv |
|||
* @param {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id). |
|||
* @return {Function} schema validating function (with property `schema`). |
|||
*/ |
|||
function getSchema(keyRef) { |
|||
var schemaObj = _getSchemaObj(this, keyRef); |
|||
switch (typeof schemaObj) { |
|||
case 'object': return schemaObj.validate || this._compile(schemaObj); |
|||
case 'string': return this.getSchema(schemaObj); |
|||
case 'undefined': return _getSchemaFragment(this, keyRef); |
|||
} |
|||
} |
|||
|
|||
|
|||
function _getSchemaFragment(self, ref) { |
|||
var res = resolve.schema.call(self, { schema: {} }, ref); |
|||
if (res) { |
|||
var schema = res.schema |
|||
, root = res.root |
|||
, baseId = res.baseId; |
|||
var v = compileSchema.call(self, schema, root, undefined, baseId); |
|||
self._fragments[ref] = new SchemaObject({ |
|||
ref: ref, |
|||
fragment: true, |
|||
schema: schema, |
|||
root: root, |
|||
baseId: baseId, |
|||
validate: v |
|||
}); |
|||
return v; |
|||
} |
|||
} |
|||
|
|||
|
|||
function _getSchemaObj(self, keyRef) { |
|||
keyRef = resolve.normalizeId(keyRef); |
|||
return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef]; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Remove cached schema(s). |
|||
* If no parameter is passed all schemas but meta-schemas are removed. |
|||
* If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. |
|||
* Even if schema is referenced by other schemas it still can be removed as other schemas have local references. |
|||
* @this Ajv |
|||
* @param {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function removeSchema(schemaKeyRef) { |
|||
if (schemaKeyRef instanceof RegExp) { |
|||
_removeAllSchemas(this, this._schemas, schemaKeyRef); |
|||
_removeAllSchemas(this, this._refs, schemaKeyRef); |
|||
return this; |
|||
} |
|||
switch (typeof schemaKeyRef) { |
|||
case 'undefined': |
|||
_removeAllSchemas(this, this._schemas); |
|||
_removeAllSchemas(this, this._refs); |
|||
this._cache.clear(); |
|||
return this; |
|||
case 'string': |
|||
var schemaObj = _getSchemaObj(this, schemaKeyRef); |
|||
if (schemaObj) this._cache.del(schemaObj.cacheKey); |
|||
delete this._schemas[schemaKeyRef]; |
|||
delete this._refs[schemaKeyRef]; |
|||
return this; |
|||
case 'object': |
|||
var serialize = this._opts.serialize; |
|||
var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef; |
|||
this._cache.del(cacheKey); |
|||
var id = this._getId(schemaKeyRef); |
|||
if (id) { |
|||
id = resolve.normalizeId(id); |
|||
delete this._schemas[id]; |
|||
delete this._refs[id]; |
|||
} |
|||
} |
|||
return this; |
|||
} |
|||
|
|||
|
|||
function _removeAllSchemas(self, schemas, regex) { |
|||
for (var keyRef in schemas) { |
|||
var schemaObj = schemas[keyRef]; |
|||
if (!schemaObj.meta && (!regex || regex.test(keyRef))) { |
|||
self._cache.del(schemaObj.cacheKey); |
|||
delete schemas[keyRef]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
/* @this Ajv */ |
|||
function _addSchema(schema, skipValidation, meta, shouldAddSchema) { |
|||
if (typeof schema != 'object' && typeof schema != 'boolean') |
|||
throw new Error('schema should be object or boolean'); |
|||
var serialize = this._opts.serialize; |
|||
var cacheKey = serialize ? serialize(schema) : schema; |
|||
var cached = this._cache.get(cacheKey); |
|||
if (cached) return cached; |
|||
|
|||
shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false; |
|||
|
|||
var id = resolve.normalizeId(this._getId(schema)); |
|||
if (id && shouldAddSchema) checkUnique(this, id); |
|||
|
|||
var willValidate = this._opts.validateSchema !== false && !skipValidation; |
|||
var recursiveMeta; |
|||
if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema))) |
|||
this.validateSchema(schema, true); |
|||
|
|||
var localRefs = resolve.ids.call(this, schema); |
|||
|
|||
var schemaObj = new SchemaObject({ |
|||
id: id, |
|||
schema: schema, |
|||
localRefs: localRefs, |
|||
cacheKey: cacheKey, |
|||
meta: meta |
|||
}); |
|||
|
|||
if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj; |
|||
this._cache.put(cacheKey, schemaObj); |
|||
|
|||
if (willValidate && recursiveMeta) this.validateSchema(schema, true); |
|||
|
|||
return schemaObj; |
|||
} |
|||
|
|||
|
|||
/* @this Ajv */ |
|||
function _compile(schemaObj, root) { |
|||
if (schemaObj.compiling) { |
|||
schemaObj.validate = callValidate; |
|||
callValidate.schema = schemaObj.schema; |
|||
callValidate.errors = null; |
|||
callValidate.root = root ? root : callValidate; |
|||
if (schemaObj.schema.$async === true) |
|||
callValidate.$async = true; |
|||
return callValidate; |
|||
} |
|||
schemaObj.compiling = true; |
|||
|
|||
var currentOpts; |
|||
if (schemaObj.meta) { |
|||
currentOpts = this._opts; |
|||
this._opts = this._metaOpts; |
|||
} |
|||
|
|||
var v; |
|||
try { v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs); } |
|||
catch(e) { |
|||
delete schemaObj.validate; |
|||
throw e; |
|||
} |
|||
finally { |
|||
schemaObj.compiling = false; |
|||
if (schemaObj.meta) this._opts = currentOpts; |
|||
} |
|||
|
|||
schemaObj.validate = v; |
|||
schemaObj.refs = v.refs; |
|||
schemaObj.refVal = v.refVal; |
|||
schemaObj.root = v.root; |
|||
return v; |
|||
|
|||
|
|||
/* @this {*} - custom context, see passContext option */ |
|||
function callValidate() { |
|||
/* jshint validthis: true */ |
|||
var _validate = schemaObj.validate; |
|||
var result = _validate.apply(this, arguments); |
|||
callValidate.errors = _validate.errors; |
|||
return result; |
|||
} |
|||
} |
|||
|
|||
|
|||
function chooseGetId(opts) { |
|||
switch (opts.schemaId) { |
|||
case 'auto': return _get$IdOrId; |
|||
case 'id': return _getId; |
|||
default: return _get$Id; |
|||
} |
|||
} |
|||
|
|||
/* @this Ajv */ |
|||
function _getId(schema) { |
|||
if (schema.$id) this.logger.warn('schema $id ignored', schema.$id); |
|||
return schema.id; |
|||
} |
|||
|
|||
/* @this Ajv */ |
|||
function _get$Id(schema) { |
|||
if (schema.id) this.logger.warn('schema id ignored', schema.id); |
|||
return schema.$id; |
|||
} |
|||
|
|||
|
|||
function _get$IdOrId(schema) { |
|||
if (schema.$id && schema.id && schema.$id != schema.id) |
|||
throw new Error('schema $id is different from id'); |
|||
return schema.$id || schema.id; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Convert array of error message objects to string |
|||
* @this Ajv |
|||
* @param {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used. |
|||
* @param {Object} options optional options with properties `separator` and `dataVar`. |
|||
* @return {String} human readable string with all errors descriptions |
|||
*/ |
|||
function errorsText(errors, options) { |
|||
errors = errors || this.errors; |
|||
if (!errors) return 'No errors'; |
|||
options = options || {}; |
|||
var separator = options.separator === undefined ? ', ' : options.separator; |
|||
var dataVar = options.dataVar === undefined ? 'data' : options.dataVar; |
|||
|
|||
var text = ''; |
|||
for (var i=0; i<errors.length; i++) { |
|||
var e = errors[i]; |
|||
if (e) text += dataVar + e.dataPath + ' ' + e.message + separator; |
|||
} |
|||
return text.slice(0, -separator.length); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Add custom format |
|||
* @this Ajv |
|||
* @param {String} name format name |
|||
* @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid) |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function addFormat(name, format) { |
|||
if (typeof format == 'string') format = new RegExp(format); |
|||
this._formats[name] = format; |
|||
return this; |
|||
} |
|||
|
|||
|
|||
function addDefaultMetaSchema(self) { |
|||
var $dataSchema; |
|||
if (self._opts.$data) { |
|||
$dataSchema = require('./refs/data.json'); |
|||
self.addMetaSchema($dataSchema, $dataSchema.$id, true); |
|||
} |
|||
if (self._opts.meta === false) return; |
|||
var metaSchema = require('./refs/json-schema-draft-07.json'); |
|||
if (self._opts.$data) metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA); |
|||
self.addMetaSchema(metaSchema, META_SCHEMA_ID, true); |
|||
self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID; |
|||
} |
|||
|
|||
|
|||
function addInitialSchemas(self) { |
|||
var optsSchemas = self._opts.schemas; |
|||
if (!optsSchemas) return; |
|||
if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas); |
|||
else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key); |
|||
} |
|||
|
|||
|
|||
function addInitialFormats(self) { |
|||
for (var name in self._opts.formats) { |
|||
var format = self._opts.formats[name]; |
|||
self.addFormat(name, format); |
|||
} |
|||
} |
|||
|
|||
|
|||
function addInitialKeywords(self) { |
|||
for (var name in self._opts.keywords) { |
|||
var keyword = self._opts.keywords[name]; |
|||
self.addKeyword(name, keyword); |
|||
} |
|||
} |
|||
|
|||
|
|||
function checkUnique(self, id) { |
|||
if (self._schemas[id] || self._refs[id]) |
|||
throw new Error('schema with key or id "' + id + '" already exists'); |
|||
} |
|||
|
|||
|
|||
function getMetaSchemaOptions(self) { |
|||
var metaOpts = util.copy(self._opts); |
|||
for (var i=0; i<META_IGNORE_OPTIONS.length; i++) |
|||
delete metaOpts[META_IGNORE_OPTIONS[i]]; |
|||
return metaOpts; |
|||
} |
|||
|
|||
|
|||
function setLogger(self) { |
|||
var logger = self._opts.logger; |
|||
if (logger === false) { |
|||
self.logger = {log: noop, warn: noop, error: noop}; |
|||
} else { |
|||
if (logger === undefined) logger = console; |
|||
if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error)) |
|||
throw new Error('logger must implement log, warn and error methods'); |
|||
self.logger = logger; |
|||
} |
|||
} |
|||
|
|||
|
|||
function noop() {} |
|||
@ -1,26 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
|
|||
var Cache = module.exports = function Cache() { |
|||
this._cache = {}; |
|||
}; |
|||
|
|||
|
|||
Cache.prototype.put = function Cache_put(key, value) { |
|||
this._cache[key] = value; |
|||
}; |
|||
|
|||
|
|||
Cache.prototype.get = function Cache_get(key) { |
|||
return this._cache[key]; |
|||
}; |
|||
|
|||
|
|||
Cache.prototype.del = function Cache_del(key) { |
|||
delete this._cache[key]; |
|||
}; |
|||
|
|||
|
|||
Cache.prototype.clear = function Cache_clear() { |
|||
this._cache = {}; |
|||
}; |
|||
@ -1,90 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var MissingRefError = require('./error_classes').MissingRef; |
|||
|
|||
module.exports = compileAsync; |
|||
|
|||
|
|||
/** |
|||
* Creates validating function for passed schema with asynchronous loading of missing schemas. |
|||
* `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema. |
|||
* @this Ajv |
|||
* @param {Object} schema schema object |
|||
* @param {Boolean} meta optional true to compile meta-schema; this parameter can be skipped |
|||
* @param {Function} callback an optional node-style callback, it is called with 2 parameters: error (or null) and validating function. |
|||
* @return {Promise} promise that resolves with a validating function. |
|||
*/ |
|||
function compileAsync(schema, meta, callback) { |
|||
/* eslint no-shadow: 0 */ |
|||
/* global Promise */ |
|||
/* jshint validthis: true */ |
|||
var self = this; |
|||
if (typeof this._opts.loadSchema != 'function') |
|||
throw new Error('options.loadSchema should be a function'); |
|||
|
|||
if (typeof meta == 'function') { |
|||
callback = meta; |
|||
meta = undefined; |
|||
} |
|||
|
|||
var p = loadMetaSchemaOf(schema).then(function () { |
|||
var schemaObj = self._addSchema(schema, undefined, meta); |
|||
return schemaObj.validate || _compileAsync(schemaObj); |
|||
}); |
|||
|
|||
if (callback) { |
|||
p.then( |
|||
function(v) { callback(null, v); }, |
|||
callback |
|||
); |
|||
} |
|||
|
|||
return p; |
|||
|
|||
|
|||
function loadMetaSchemaOf(sch) { |
|||
var $schema = sch.$schema; |
|||
return $schema && !self.getSchema($schema) |
|||
? compileAsync.call(self, { $ref: $schema }, true) |
|||
: Promise.resolve(); |
|||
} |
|||
|
|||
|
|||
function _compileAsync(schemaObj) { |
|||
try { return self._compile(schemaObj); } |
|||
catch(e) { |
|||
if (e instanceof MissingRefError) return loadMissingSchema(e); |
|||
throw e; |
|||
} |
|||
|
|||
|
|||
function loadMissingSchema(e) { |
|||
var ref = e.missingSchema; |
|||
if (added(ref)) throw new Error('Schema ' + ref + ' is loaded but ' + e.missingRef + ' cannot be resolved'); |
|||
|
|||
var schemaPromise = self._loadingSchemas[ref]; |
|||
if (!schemaPromise) { |
|||
schemaPromise = self._loadingSchemas[ref] = self._opts.loadSchema(ref); |
|||
schemaPromise.then(removePromise, removePromise); |
|||
} |
|||
|
|||
return schemaPromise.then(function (sch) { |
|||
if (!added(ref)) { |
|||
return loadMetaSchemaOf(sch).then(function () { |
|||
if (!added(ref)) self.addSchema(sch, ref, undefined, meta); |
|||
}); |
|||
} |
|||
}).then(function() { |
|||
return _compileAsync(schemaObj); |
|||
}); |
|||
|
|||
function removePromise() { |
|||
delete self._loadingSchemas[ref]; |
|||
} |
|||
|
|||
function added(ref) { |
|||
return self._refs[ref] || self._schemas[ref]; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,5 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
// do NOT remove this file - it would break pre-compiled schemas
|
|||
// https://github.com/ajv-validator/ajv/issues/889
|
|||
module.exports = require('fast-deep-equal'); |
|||
@ -1,34 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var resolve = require('./resolve'); |
|||
|
|||
module.exports = { |
|||
Validation: errorSubclass(ValidationError), |
|||
MissingRef: errorSubclass(MissingRefError) |
|||
}; |
|||
|
|||
|
|||
function ValidationError(errors) { |
|||
this.message = 'validation failed'; |
|||
this.errors = errors; |
|||
this.ajv = this.validation = true; |
|||
} |
|||
|
|||
|
|||
MissingRefError.message = function (baseId, ref) { |
|||
return 'can\'t resolve reference ' + ref + ' from id ' + baseId; |
|||
}; |
|||
|
|||
|
|||
function MissingRefError(baseId, ref, message) { |
|||
this.message = message || MissingRefError.message(baseId, ref); |
|||
this.missingRef = resolve.url(baseId, ref); |
|||
this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef)); |
|||
} |
|||
|
|||
|
|||
function errorSubclass(Subclass) { |
|||
Subclass.prototype = Object.create(Error.prototype); |
|||
Subclass.prototype.constructor = Subclass; |
|||
return Subclass; |
|||
} |
|||
@ -1,142 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var util = require('./util'); |
|||
|
|||
var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; |
|||
var DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31]; |
|||
var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i; |
|||
var 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; |
|||
var URI = /^(?:[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; |
|||
var 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; |
|||
// uri-template: https://tools.ietf.org/html/rfc6570
|
|||
var 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; |
|||
// For the source: https://gist.github.com/dperini/729294
|
|||
// For test cases: https://mathiasbynens.be/demo/url-regex
|
|||
// @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983.
|
|||
// var 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;
|
|||
var URL = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i; |
|||
var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i; |
|||
var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/; |
|||
var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i; |
|||
var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/; |
|||
|
|||
|
|||
module.exports = formats; |
|||
|
|||
function formats(mode) { |
|||
mode = mode == 'full' ? 'full' : 'fast'; |
|||
return util.copy(formats[mode]); |
|||
} |
|||
|
|||
|
|||
formats.fast = { |
|||
// date: http://tools.ietf.org/html/rfc3339#section-5.6
|
|||
date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/, |
|||
// date-time: http://tools.ietf.org/html/rfc3339#section-5.6
|
|||
time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, |
|||
'date-time': /^\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, |
|||
// uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
|
|||
uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, |
|||
'uri-reference': /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, |
|||
'uri-template': URITEMPLATE, |
|||
url: URL, |
|||
// email (sources from jsen validator):
|
|||
// http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
|
|||
// http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')
|
|||
email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i, |
|||
hostname: HOSTNAME, |
|||
// optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
|
|||
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, |
|||
// optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses
|
|||
ipv6: /^\s*(?:(?:(?:[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}))|:)))(?:%.+)?\s*$/i, |
|||
regex: regex, |
|||
// uuid: http://tools.ietf.org/html/rfc4122
|
|||
uuid: UUID, |
|||
// JSON-pointer: https://tools.ietf.org/html/rfc6901
|
|||
// uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
|
|||
'json-pointer': JSON_POINTER, |
|||
'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT, |
|||
// relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
|
|||
'relative-json-pointer': RELATIVE_JSON_POINTER |
|||
}; |
|||
|
|||
|
|||
formats.full = { |
|||
date: date, |
|||
time: time, |
|||
'date-time': date_time, |
|||
uri: uri, |
|||
'uri-reference': URIREF, |
|||
'uri-template': URITEMPLATE, |
|||
url: URL, |
|||
email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, |
|||
hostname: HOSTNAME, |
|||
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, |
|||
ipv6: /^\s*(?:(?:(?:[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}))|:)))(?:%.+)?\s*$/i, |
|||
regex: regex, |
|||
uuid: UUID, |
|||
'json-pointer': JSON_POINTER, |
|||
'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT, |
|||
'relative-json-pointer': RELATIVE_JSON_POINTER |
|||
}; |
|||
|
|||
|
|||
function isLeapYear(year) { |
|||
// https://tools.ietf.org/html/rfc3339#appendix-C
|
|||
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); |
|||
} |
|||
|
|||
|
|||
function date(str) { |
|||
// full-date from http://tools.ietf.org/html/rfc3339#section-5.6
|
|||
var matches = str.match(DATE); |
|||
if (!matches) return false; |
|||
|
|||
var year = +matches[1]; |
|||
var month = +matches[2]; |
|||
var day = +matches[3]; |
|||
|
|||
return month >= 1 && month <= 12 && day >= 1 && |
|||
day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]); |
|||
} |
|||
|
|||
|
|||
function time(str, full) { |
|||
var matches = str.match(TIME); |
|||
if (!matches) return false; |
|||
|
|||
var hour = matches[1]; |
|||
var minute = matches[2]; |
|||
var second = matches[3]; |
|||
var timeZone = matches[5]; |
|||
return ((hour <= 23 && minute <= 59 && second <= 59) || |
|||
(hour == 23 && minute == 59 && second == 60)) && |
|||
(!full || timeZone); |
|||
} |
|||
|
|||
|
|||
var DATE_TIME_SEPARATOR = /t|\s/i; |
|||
function date_time(str) { |
|||
// http://tools.ietf.org/html/rfc3339#section-5.6
|
|||
var dateTime = str.split(DATE_TIME_SEPARATOR); |
|||
return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true); |
|||
} |
|||
|
|||
|
|||
var NOT_URI_FRAGMENT = /\/|:/; |
|||
function uri(str) { |
|||
// http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required "."
|
|||
return NOT_URI_FRAGMENT.test(str) && URI.test(str); |
|||
} |
|||
|
|||
|
|||
var Z_ANCHOR = /[^\\]\\Z/; |
|||
function regex(str) { |
|||
if (Z_ANCHOR.test(str)) return false; |
|||
try { |
|||
new RegExp(str); |
|||
return true; |
|||
} catch(e) { |
|||
return false; |
|||
} |
|||
} |
|||
@ -1,387 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var resolve = require('./resolve') |
|||
, util = require('./util') |
|||
, errorClasses = require('./error_classes') |
|||
, stableStringify = require('fast-json-stable-stringify'); |
|||
|
|||
var validateGenerator = require('../dotjs/validate'); |
|||
|
|||
/** |
|||
* Functions below are used inside compiled validations function |
|||
*/ |
|||
|
|||
var ucs2length = util.ucs2length; |
|||
var equal = require('fast-deep-equal'); |
|||
|
|||
// this error is thrown by async schemas to return validation errors via exception
|
|||
var ValidationError = errorClasses.Validation; |
|||
|
|||
module.exports = compile; |
|||
|
|||
|
|||
/** |
|||
* Compiles schema to validation function |
|||
* @this Ajv |
|||
* @param {Object} schema schema object |
|||
* @param {Object} root object with information about the root schema for this schema |
|||
* @param {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution |
|||
* @param {String} baseId base ID for IDs in the schema |
|||
* @return {Function} validation function |
|||
*/ |
|||
function compile(schema, root, localRefs, baseId) { |
|||
/* jshint validthis: true, evil: true */ |
|||
/* eslint no-shadow: 0 */ |
|||
var self = this |
|||
, opts = this._opts |
|||
, refVal = [ undefined ] |
|||
, refs = {} |
|||
, patterns = [] |
|||
, patternsHash = {} |
|||
, defaults = [] |
|||
, defaultsHash = {} |
|||
, customRules = []; |
|||
|
|||
root = root || { schema: schema, refVal: refVal, refs: refs }; |
|||
|
|||
var c = checkCompiling.call(this, schema, root, baseId); |
|||
var compilation = this._compilations[c.index]; |
|||
if (c.compiling) return (compilation.callValidate = callValidate); |
|||
|
|||
var formats = this._formats; |
|||
var RULES = this.RULES; |
|||
|
|||
try { |
|||
var v = localCompile(schema, root, localRefs, baseId); |
|||
compilation.validate = v; |
|||
var cv = compilation.callValidate; |
|||
if (cv) { |
|||
cv.schema = v.schema; |
|||
cv.errors = null; |
|||
cv.refs = v.refs; |
|||
cv.refVal = v.refVal; |
|||
cv.root = v.root; |
|||
cv.$async = v.$async; |
|||
if (opts.sourceCode) cv.source = v.source; |
|||
} |
|||
return v; |
|||
} finally { |
|||
endCompiling.call(this, schema, root, baseId); |
|||
} |
|||
|
|||
/* @this {*} - custom context, see passContext option */ |
|||
function callValidate() { |
|||
/* jshint validthis: true */ |
|||
var validate = compilation.validate; |
|||
var result = validate.apply(this, arguments); |
|||
callValidate.errors = validate.errors; |
|||
return result; |
|||
} |
|||
|
|||
function localCompile(_schema, _root, localRefs, baseId) { |
|||
var isRoot = !_root || (_root && _root.schema == _schema); |
|||
if (_root.schema != root.schema) |
|||
return compile.call(self, _schema, _root, localRefs, baseId); |
|||
|
|||
var $async = _schema.$async === true; |
|||
|
|||
var sourceCode = validateGenerator({ |
|||
isTop: true, |
|||
schema: _schema, |
|||
isRoot: isRoot, |
|||
baseId: baseId, |
|||
root: _root, |
|||
schemaPath: '', |
|||
errSchemaPath: '#', |
|||
errorPath: '""', |
|||
MissingRefError: errorClasses.MissingRef, |
|||
RULES: RULES, |
|||
validate: validateGenerator, |
|||
util: util, |
|||
resolve: resolve, |
|||
resolveRef: resolveRef, |
|||
usePattern: usePattern, |
|||
useDefault: useDefault, |
|||
useCustomRule: useCustomRule, |
|||
opts: opts, |
|||
formats: formats, |
|||
logger: self.logger, |
|||
self: self |
|||
}); |
|||
|
|||
sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) |
|||
+ vars(defaults, defaultCode) + vars(customRules, customRuleCode) |
|||
+ sourceCode; |
|||
|
|||
if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema); |
|||
// console.log('\n\n\n *** \n', JSON.stringify(sourceCode));
|
|||
var validate; |
|||
try { |
|||
var makeValidate = new Function( |
|||
'self', |
|||
'RULES', |
|||
'formats', |
|||
'root', |
|||
'refVal', |
|||
'defaults', |
|||
'customRules', |
|||
'equal', |
|||
'ucs2length', |
|||
'ValidationError', |
|||
sourceCode |
|||
); |
|||
|
|||
validate = makeValidate( |
|||
self, |
|||
RULES, |
|||
formats, |
|||
root, |
|||
refVal, |
|||
defaults, |
|||
customRules, |
|||
equal, |
|||
ucs2length, |
|||
ValidationError |
|||
); |
|||
|
|||
refVal[0] = validate; |
|||
} catch(e) { |
|||
self.logger.error('Error compiling schema, function code:', sourceCode); |
|||
throw e; |
|||
} |
|||
|
|||
validate.schema = _schema; |
|||
validate.errors = null; |
|||
validate.refs = refs; |
|||
validate.refVal = refVal; |
|||
validate.root = isRoot ? validate : _root; |
|||
if ($async) validate.$async = true; |
|||
if (opts.sourceCode === true) { |
|||
validate.source = { |
|||
code: sourceCode, |
|||
patterns: patterns, |
|||
defaults: defaults |
|||
}; |
|||
} |
|||
|
|||
return validate; |
|||
} |
|||
|
|||
function resolveRef(baseId, ref, isRoot) { |
|||
ref = resolve.url(baseId, ref); |
|||
var refIndex = refs[ref]; |
|||
var _refVal, refCode; |
|||
if (refIndex !== undefined) { |
|||
_refVal = refVal[refIndex]; |
|||
refCode = 'refVal[' + refIndex + ']'; |
|||
return resolvedRef(_refVal, refCode); |
|||
} |
|||
if (!isRoot && root.refs) { |
|||
var rootRefId = root.refs[ref]; |
|||
if (rootRefId !== undefined) { |
|||
_refVal = root.refVal[rootRefId]; |
|||
refCode = addLocalRef(ref, _refVal); |
|||
return resolvedRef(_refVal, refCode); |
|||
} |
|||
} |
|||
|
|||
refCode = addLocalRef(ref); |
|||
var v = resolve.call(self, localCompile, root, ref); |
|||
if (v === undefined) { |
|||
var localSchema = localRefs && localRefs[ref]; |
|||
if (localSchema) { |
|||
v = resolve.inlineRef(localSchema, opts.inlineRefs) |
|||
? localSchema |
|||
: compile.call(self, localSchema, root, localRefs, baseId); |
|||
} |
|||
} |
|||
|
|||
if (v === undefined) { |
|||
removeLocalRef(ref); |
|||
} else { |
|||
replaceLocalRef(ref, v); |
|||
return resolvedRef(v, refCode); |
|||
} |
|||
} |
|||
|
|||
function addLocalRef(ref, v) { |
|||
var refId = refVal.length; |
|||
refVal[refId] = v; |
|||
refs[ref] = refId; |
|||
return 'refVal' + refId; |
|||
} |
|||
|
|||
function removeLocalRef(ref) { |
|||
delete refs[ref]; |
|||
} |
|||
|
|||
function replaceLocalRef(ref, v) { |
|||
var refId = refs[ref]; |
|||
refVal[refId] = v; |
|||
} |
|||
|
|||
function resolvedRef(refVal, code) { |
|||
return typeof refVal == 'object' || typeof refVal == 'boolean' |
|||
? { code: code, schema: refVal, inline: true } |
|||
: { code: code, $async: refVal && !!refVal.$async }; |
|||
} |
|||
|
|||
function usePattern(regexStr) { |
|||
var index = patternsHash[regexStr]; |
|||
if (index === undefined) { |
|||
index = patternsHash[regexStr] = patterns.length; |
|||
patterns[index] = regexStr; |
|||
} |
|||
return 'pattern' + index; |
|||
} |
|||
|
|||
function useDefault(value) { |
|||
switch (typeof value) { |
|||
case 'boolean': |
|||
case 'number': |
|||
return '' + value; |
|||
case 'string': |
|||
return util.toQuotedString(value); |
|||
case 'object': |
|||
if (value === null) return 'null'; |
|||
var valueStr = stableStringify(value); |
|||
var index = defaultsHash[valueStr]; |
|||
if (index === undefined) { |
|||
index = defaultsHash[valueStr] = defaults.length; |
|||
defaults[index] = value; |
|||
} |
|||
return 'default' + index; |
|||
} |
|||
} |
|||
|
|||
function useCustomRule(rule, schema, parentSchema, it) { |
|||
if (self._opts.validateSchema !== false) { |
|||
var deps = rule.definition.dependencies; |
|||
if (deps && !deps.every(function(keyword) { |
|||
return Object.prototype.hasOwnProperty.call(parentSchema, keyword); |
|||
})) |
|||
throw new Error('parent schema must have all required keywords: ' + deps.join(',')); |
|||
|
|||
var validateSchema = rule.definition.validateSchema; |
|||
if (validateSchema) { |
|||
var valid = validateSchema(schema); |
|||
if (!valid) { |
|||
var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors); |
|||
if (self._opts.validateSchema == 'log') self.logger.error(message); |
|||
else throw new Error(message); |
|||
} |
|||
} |
|||
} |
|||
|
|||
var compile = rule.definition.compile |
|||
, inline = rule.definition.inline |
|||
, macro = rule.definition.macro; |
|||
|
|||
var validate; |
|||
if (compile) { |
|||
validate = compile.call(self, schema, parentSchema, it); |
|||
} else if (macro) { |
|||
validate = macro.call(self, schema, parentSchema, it); |
|||
if (opts.validateSchema !== false) self.validateSchema(validate, true); |
|||
} else if (inline) { |
|||
validate = inline.call(self, it, rule.keyword, schema, parentSchema); |
|||
} else { |
|||
validate = rule.definition.validate; |
|||
if (!validate) return; |
|||
} |
|||
|
|||
if (validate === undefined) |
|||
throw new Error('custom keyword "' + rule.keyword + '"failed to compile'); |
|||
|
|||
var index = customRules.length; |
|||
customRules[index] = validate; |
|||
|
|||
return { |
|||
code: 'customRule' + index, |
|||
validate: validate |
|||
}; |
|||
} |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Checks if the schema is currently compiled |
|||
* @this Ajv |
|||
* @param {Object} schema schema to compile |
|||
* @param {Object} root root object |
|||
* @param {String} baseId base schema ID |
|||
* @return {Object} object with properties "index" (compilation index) and "compiling" (boolean) |
|||
*/ |
|||
function checkCompiling(schema, root, baseId) { |
|||
/* jshint validthis: true */ |
|||
var index = compIndex.call(this, schema, root, baseId); |
|||
if (index >= 0) return { index: index, compiling: true }; |
|||
index = this._compilations.length; |
|||
this._compilations[index] = { |
|||
schema: schema, |
|||
root: root, |
|||
baseId: baseId |
|||
}; |
|||
return { index: index, compiling: false }; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Removes the schema from the currently compiled list |
|||
* @this Ajv |
|||
* @param {Object} schema schema to compile |
|||
* @param {Object} root root object |
|||
* @param {String} baseId base schema ID |
|||
*/ |
|||
function endCompiling(schema, root, baseId) { |
|||
/* jshint validthis: true */ |
|||
var i = compIndex.call(this, schema, root, baseId); |
|||
if (i >= 0) this._compilations.splice(i, 1); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Index of schema compilation in the currently compiled list |
|||
* @this Ajv |
|||
* @param {Object} schema schema to compile |
|||
* @param {Object} root root object |
|||
* @param {String} baseId base schema ID |
|||
* @return {Integer} compilation index |
|||
*/ |
|||
function compIndex(schema, root, baseId) { |
|||
/* jshint validthis: true */ |
|||
for (var i=0; i<this._compilations.length; i++) { |
|||
var c = this._compilations[i]; |
|||
if (c.schema == schema && c.root == root && c.baseId == baseId) return i; |
|||
} |
|||
return -1; |
|||
} |
|||
|
|||
|
|||
function patternCode(i, patterns) { |
|||
return 'var pattern' + i + ' = new RegExp(' + util.toQuotedString(patterns[i]) + ');'; |
|||
} |
|||
|
|||
|
|||
function defaultCode(i) { |
|||
return 'var default' + i + ' = defaults[' + i + '];'; |
|||
} |
|||
|
|||
|
|||
function refValCode(i, refVal) { |
|||
return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];'; |
|||
} |
|||
|
|||
|
|||
function customRuleCode(i) { |
|||
return 'var customRule' + i + ' = customRules[' + i + '];'; |
|||
} |
|||
|
|||
|
|||
function vars(arr, statement) { |
|||
if (!arr.length) return ''; |
|||
var code = ''; |
|||
for (var i=0; i<arr.length; i++) |
|||
code += statement(i, arr); |
|||
return code; |
|||
} |
|||
@ -1,270 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var URI = require('uri-js') |
|||
, equal = require('fast-deep-equal') |
|||
, util = require('./util') |
|||
, SchemaObject = require('./schema_obj') |
|||
, traverse = require('json-schema-traverse'); |
|||
|
|||
module.exports = resolve; |
|||
|
|||
resolve.normalizeId = normalizeId; |
|||
resolve.fullPath = getFullPath; |
|||
resolve.url = resolveUrl; |
|||
resolve.ids = resolveIds; |
|||
resolve.inlineRef = inlineRef; |
|||
resolve.schema = resolveSchema; |
|||
|
|||
/** |
|||
* [resolve and compile the references ($ref)] |
|||
* @this Ajv |
|||
* @param {Function} compile reference to schema compilation funciton (localCompile) |
|||
* @param {Object} root object with information about the root schema for the current schema |
|||
* @param {String} ref reference to resolve |
|||
* @return {Object|Function} schema object (if the schema can be inlined) or validation function |
|||
*/ |
|||
function resolve(compile, root, ref) { |
|||
/* jshint validthis: true */ |
|||
var refVal = this._refs[ref]; |
|||
if (typeof refVal == 'string') { |
|||
if (this._refs[refVal]) refVal = this._refs[refVal]; |
|||
else return resolve.call(this, compile, root, refVal); |
|||
} |
|||
|
|||
refVal = refVal || this._schemas[ref]; |
|||
if (refVal instanceof SchemaObject) { |
|||
return inlineRef(refVal.schema, this._opts.inlineRefs) |
|||
? refVal.schema |
|||
: refVal.validate || this._compile(refVal); |
|||
} |
|||
|
|||
var res = resolveSchema.call(this, root, ref); |
|||
var schema, v, baseId; |
|||
if (res) { |
|||
schema = res.schema; |
|||
root = res.root; |
|||
baseId = res.baseId; |
|||
} |
|||
|
|||
if (schema instanceof SchemaObject) { |
|||
v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId); |
|||
} else if (schema !== undefined) { |
|||
v = inlineRef(schema, this._opts.inlineRefs) |
|||
? schema |
|||
: compile.call(this, schema, root, undefined, baseId); |
|||
} |
|||
|
|||
return v; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Resolve schema, its root and baseId |
|||
* @this Ajv |
|||
* @param {Object} root root object with properties schema, refVal, refs |
|||
* @param {String} ref reference to resolve |
|||
* @return {Object} object with properties schema, root, baseId |
|||
*/ |
|||
function resolveSchema(root, ref) { |
|||
/* jshint validthis: true */ |
|||
var p = URI.parse(ref) |
|||
, refPath = _getFullPath(p) |
|||
, baseId = getFullPath(this._getId(root.schema)); |
|||
if (Object.keys(root.schema).length === 0 || refPath !== baseId) { |
|||
var id = normalizeId(refPath); |
|||
var refVal = this._refs[id]; |
|||
if (typeof refVal == 'string') { |
|||
return resolveRecursive.call(this, root, refVal, p); |
|||
} else if (refVal instanceof SchemaObject) { |
|||
if (!refVal.validate) this._compile(refVal); |
|||
root = refVal; |
|||
} else { |
|||
refVal = this._schemas[id]; |
|||
if (refVal instanceof SchemaObject) { |
|||
if (!refVal.validate) this._compile(refVal); |
|||
if (id == normalizeId(ref)) |
|||
return { schema: refVal, root: root, baseId: baseId }; |
|||
root = refVal; |
|||
} else { |
|||
return; |
|||
} |
|||
} |
|||
if (!root.schema) return; |
|||
baseId = getFullPath(this._getId(root.schema)); |
|||
} |
|||
return getJsonPointer.call(this, p, baseId, root.schema, root); |
|||
} |
|||
|
|||
|
|||
/* @this Ajv */ |
|||
function resolveRecursive(root, ref, parsedRef) { |
|||
/* jshint validthis: true */ |
|||
var res = resolveSchema.call(this, root, ref); |
|||
if (res) { |
|||
var schema = res.schema; |
|||
var baseId = res.baseId; |
|||
root = res.root; |
|||
var id = this._getId(schema); |
|||
if (id) baseId = resolveUrl(baseId, id); |
|||
return getJsonPointer.call(this, parsedRef, baseId, schema, root); |
|||
} |
|||
} |
|||
|
|||
|
|||
var PREVENT_SCOPE_CHANGE = util.toHash(['properties', 'patternProperties', 'enum', 'dependencies', 'definitions']); |
|||
/* @this Ajv */ |
|||
function getJsonPointer(parsedRef, baseId, schema, root) { |
|||
/* jshint validthis: true */ |
|||
parsedRef.fragment = parsedRef.fragment || ''; |
|||
if (parsedRef.fragment.slice(0,1) != '/') return; |
|||
var parts = parsedRef.fragment.split('/'); |
|||
|
|||
for (var i = 1; i < parts.length; i++) { |
|||
var part = parts[i]; |
|||
if (part) { |
|||
part = util.unescapeFragment(part); |
|||
schema = schema[part]; |
|||
if (schema === undefined) break; |
|||
var id; |
|||
if (!PREVENT_SCOPE_CHANGE[part]) { |
|||
id = this._getId(schema); |
|||
if (id) baseId = resolveUrl(baseId, id); |
|||
if (schema.$ref) { |
|||
var $ref = resolveUrl(baseId, schema.$ref); |
|||
var res = resolveSchema.call(this, root, $ref); |
|||
if (res) { |
|||
schema = res.schema; |
|||
root = res.root; |
|||
baseId = res.baseId; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if (schema !== undefined && schema !== root.schema) |
|||
return { schema: schema, root: root, baseId: baseId }; |
|||
} |
|||
|
|||
|
|||
var SIMPLE_INLINED = util.toHash([ |
|||
'type', 'format', 'pattern', |
|||
'maxLength', 'minLength', |
|||
'maxProperties', 'minProperties', |
|||
'maxItems', 'minItems', |
|||
'maximum', 'minimum', |
|||
'uniqueItems', 'multipleOf', |
|||
'required', 'enum' |
|||
]); |
|||
function inlineRef(schema, limit) { |
|||
if (limit === false) return false; |
|||
if (limit === undefined || limit === true) return checkNoRef(schema); |
|||
else if (limit) return countKeys(schema) <= limit; |
|||
} |
|||
|
|||
|
|||
function checkNoRef(schema) { |
|||
var item; |
|||
if (Array.isArray(schema)) { |
|||
for (var i=0; i<schema.length; i++) { |
|||
item = schema[i]; |
|||
if (typeof item == 'object' && !checkNoRef(item)) return false; |
|||
} |
|||
} else { |
|||
for (var key in schema) { |
|||
if (key == '$ref') return false; |
|||
item = schema[key]; |
|||
if (typeof item == 'object' && !checkNoRef(item)) return false; |
|||
} |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
|
|||
function countKeys(schema) { |
|||
var count = 0, item; |
|||
if (Array.isArray(schema)) { |
|||
for (var i=0; i<schema.length; i++) { |
|||
item = schema[i]; |
|||
if (typeof item == 'object') count += countKeys(item); |
|||
if (count == Infinity) return Infinity; |
|||
} |
|||
} else { |
|||
for (var key in schema) { |
|||
if (key == '$ref') return Infinity; |
|||
if (SIMPLE_INLINED[key]) { |
|||
count++; |
|||
} else { |
|||
item = schema[key]; |
|||
if (typeof item == 'object') count += countKeys(item) + 1; |
|||
if (count == Infinity) return Infinity; |
|||
} |
|||
} |
|||
} |
|||
return count; |
|||
} |
|||
|
|||
|
|||
function getFullPath(id, normalize) { |
|||
if (normalize !== false) id = normalizeId(id); |
|||
var p = URI.parse(id); |
|||
return _getFullPath(p); |
|||
} |
|||
|
|||
|
|||
function _getFullPath(p) { |
|||
return URI.serialize(p).split('#')[0] + '#'; |
|||
} |
|||
|
|||
|
|||
var TRAILING_SLASH_HASH = /#\/?$/; |
|||
function normalizeId(id) { |
|||
return id ? id.replace(TRAILING_SLASH_HASH, '') : ''; |
|||
} |
|||
|
|||
|
|||
function resolveUrl(baseId, id) { |
|||
id = normalizeId(id); |
|||
return URI.resolve(baseId, id); |
|||
} |
|||
|
|||
|
|||
/* @this Ajv */ |
|||
function resolveIds(schema) { |
|||
var schemaId = normalizeId(this._getId(schema)); |
|||
var baseIds = {'': schemaId}; |
|||
var fullPaths = {'': getFullPath(schemaId, false)}; |
|||
var localRefs = {}; |
|||
var self = this; |
|||
|
|||
traverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { |
|||
if (jsonPtr === '') return; |
|||
var id = self._getId(sch); |
|||
var baseId = baseIds[parentJsonPtr]; |
|||
var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword; |
|||
if (keyIndex !== undefined) |
|||
fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util.escapeFragment(keyIndex)); |
|||
|
|||
if (typeof id == 'string') { |
|||
id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id); |
|||
|
|||
var refVal = self._refs[id]; |
|||
if (typeof refVal == 'string') refVal = self._refs[refVal]; |
|||
if (refVal && refVal.schema) { |
|||
if (!equal(sch, refVal.schema)) |
|||
throw new Error('id "' + id + '" resolves to more than one schema'); |
|||
} else if (id != normalizeId(fullPath)) { |
|||
if (id[0] == '#') { |
|||
if (localRefs[id] && !equal(sch, localRefs[id])) |
|||
throw new Error('id "' + id + '" resolves to more than one schema'); |
|||
localRefs[id] = sch; |
|||
} else { |
|||
self._refs[id] = fullPath; |
|||
} |
|||
} |
|||
} |
|||
baseIds[jsonPtr] = baseId; |
|||
fullPaths[jsonPtr] = fullPath; |
|||
}); |
|||
|
|||
return localRefs; |
|||
} |
|||
@ -1,66 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var ruleModules = require('../dotjs') |
|||
, toHash = require('./util').toHash; |
|||
|
|||
module.exports = function rules() { |
|||
var RULES = [ |
|||
{ type: 'number', |
|||
rules: [ { 'maximum': ['exclusiveMaximum'] }, |
|||
{ 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] }, |
|||
{ type: 'string', |
|||
rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] }, |
|||
{ type: 'array', |
|||
rules: [ 'maxItems', 'minItems', 'items', 'contains', 'uniqueItems' ] }, |
|||
{ type: 'object', |
|||
rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames', |
|||
{ 'properties': ['additionalProperties', 'patternProperties'] } ] }, |
|||
{ rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] } |
|||
]; |
|||
|
|||
var ALL = [ 'type', '$comment' ]; |
|||
var KEYWORDS = [ |
|||
'$schema', '$id', 'id', '$data', '$async', 'title', |
|||
'description', 'default', 'definitions', |
|||
'examples', 'readOnly', 'writeOnly', |
|||
'contentMediaType', 'contentEncoding', |
|||
'additionalItems', 'then', 'else' |
|||
]; |
|||
var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ]; |
|||
RULES.all = toHash(ALL); |
|||
RULES.types = toHash(TYPES); |
|||
|
|||
RULES.forEach(function (group) { |
|||
group.rules = group.rules.map(function (keyword) { |
|||
var implKeywords; |
|||
if (typeof keyword == 'object') { |
|||
var key = Object.keys(keyword)[0]; |
|||
implKeywords = keyword[key]; |
|||
keyword = key; |
|||
implKeywords.forEach(function (k) { |
|||
ALL.push(k); |
|||
RULES.all[k] = true; |
|||
}); |
|||
} |
|||
ALL.push(keyword); |
|||
var rule = RULES.all[keyword] = { |
|||
keyword: keyword, |
|||
code: ruleModules[keyword], |
|||
implements: implKeywords |
|||
}; |
|||
return rule; |
|||
}); |
|||
|
|||
RULES.all.$comment = { |
|||
keyword: '$comment', |
|||
code: ruleModules.$comment |
|||
}; |
|||
|
|||
if (group.type) RULES.types[group.type] = group; |
|||
}); |
|||
|
|||
RULES.keywords = toHash(ALL.concat(KEYWORDS)); |
|||
RULES.custom = {}; |
|||
|
|||
return RULES; |
|||
}; |
|||
@ -1,9 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var util = require('./util'); |
|||
|
|||
module.exports = SchemaObject; |
|||
|
|||
function SchemaObject(obj) { |
|||
util.copy(obj, this); |
|||
} |
|||
@ -1,20 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
// https://mathiasbynens.be/notes/javascript-encoding
|
|||
// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode
|
|||
module.exports = function ucs2length(str) { |
|||
var length = 0 |
|||
, len = str.length |
|||
, pos = 0 |
|||
, value; |
|||
while (pos < len) { |
|||
length++; |
|||
value = str.charCodeAt(pos++); |
|||
if (value >= 0xD800 && value <= 0xDBFF && pos < len) { |
|||
// high surrogate, and there is a next character
|
|||
value = str.charCodeAt(pos); |
|||
if ((value & 0xFC00) == 0xDC00) pos++; // low surrogate
|
|||
} |
|||
} |
|||
return length; |
|||
}; |
|||
@ -1,239 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
|
|||
module.exports = { |
|||
copy: copy, |
|||
checkDataType: checkDataType, |
|||
checkDataTypes: checkDataTypes, |
|||
coerceToTypes: coerceToTypes, |
|||
toHash: toHash, |
|||
getProperty: getProperty, |
|||
escapeQuotes: escapeQuotes, |
|||
equal: require('fast-deep-equal'), |
|||
ucs2length: require('./ucs2length'), |
|||
varOccurences: varOccurences, |
|||
varReplace: varReplace, |
|||
schemaHasRules: schemaHasRules, |
|||
schemaHasRulesExcept: schemaHasRulesExcept, |
|||
schemaUnknownRules: schemaUnknownRules, |
|||
toQuotedString: toQuotedString, |
|||
getPathExpr: getPathExpr, |
|||
getPath: getPath, |
|||
getData: getData, |
|||
unescapeFragment: unescapeFragment, |
|||
unescapeJsonPointer: unescapeJsonPointer, |
|||
escapeFragment: escapeFragment, |
|||
escapeJsonPointer: escapeJsonPointer |
|||
}; |
|||
|
|||
|
|||
function copy(o, to) { |
|||
to = to || {}; |
|||
for (var key in o) to[key] = o[key]; |
|||
return to; |
|||
} |
|||
|
|||
|
|||
function checkDataType(dataType, data, strictNumbers, negate) { |
|||
var EQUAL = negate ? ' !== ' : ' === ' |
|||
, AND = negate ? ' || ' : ' && ' |
|||
, OK = negate ? '!' : '' |
|||
, NOT = negate ? '' : '!'; |
|||
switch (dataType) { |
|||
case 'null': return data + EQUAL + 'null'; |
|||
case 'array': return OK + 'Array.isArray(' + data + ')'; |
|||
case 'object': return '(' + OK + data + AND + |
|||
'typeof ' + data + EQUAL + '"object"' + AND + |
|||
NOT + 'Array.isArray(' + data + '))'; |
|||
case 'integer': return '(typeof ' + data + EQUAL + '"number"' + AND + |
|||
NOT + '(' + data + ' % 1)' + |
|||
AND + data + EQUAL + data + |
|||
(strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')'; |
|||
case 'number': return '(typeof ' + data + EQUAL + '"' + dataType + '"' + |
|||
(strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')'; |
|||
default: return 'typeof ' + data + EQUAL + '"' + dataType + '"'; |
|||
} |
|||
} |
|||
|
|||
|
|||
function checkDataTypes(dataTypes, data, strictNumbers) { |
|||
switch (dataTypes.length) { |
|||
case 1: return checkDataType(dataTypes[0], data, strictNumbers, true); |
|||
default: |
|||
var code = ''; |
|||
var types = toHash(dataTypes); |
|||
if (types.array && types.object) { |
|||
code = types.null ? '(': '(!' + data + ' || '; |
|||
code += 'typeof ' + data + ' !== "object")'; |
|||
delete types.null; |
|||
delete types.array; |
|||
delete types.object; |
|||
} |
|||
if (types.number) delete types.integer; |
|||
for (var t in types) |
|||
code += (code ? ' && ' : '' ) + checkDataType(t, data, strictNumbers, true); |
|||
|
|||
return code; |
|||
} |
|||
} |
|||
|
|||
|
|||
var COERCE_TO_TYPES = toHash([ 'string', 'number', 'integer', 'boolean', 'null' ]); |
|||
function coerceToTypes(optionCoerceTypes, dataTypes) { |
|||
if (Array.isArray(dataTypes)) { |
|||
var types = []; |
|||
for (var i=0; i<dataTypes.length; i++) { |
|||
var t = dataTypes[i]; |
|||
if (COERCE_TO_TYPES[t]) types[types.length] = t; |
|||
else if (optionCoerceTypes === 'array' && t === 'array') types[types.length] = t; |
|||
} |
|||
if (types.length) return types; |
|||
} else if (COERCE_TO_TYPES[dataTypes]) { |
|||
return [dataTypes]; |
|||
} else if (optionCoerceTypes === 'array' && dataTypes === 'array') { |
|||
return ['array']; |
|||
} |
|||
} |
|||
|
|||
|
|||
function toHash(arr) { |
|||
var hash = {}; |
|||
for (var i=0; i<arr.length; i++) hash[arr[i]] = true; |
|||
return hash; |
|||
} |
|||
|
|||
|
|||
var IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; |
|||
var SINGLE_QUOTE = /'|\\/g; |
|||
function getProperty(key) { |
|||
return typeof key == 'number' |
|||
? '[' + key + ']' |
|||
: IDENTIFIER.test(key) |
|||
? '.' + key |
|||
: "['" + escapeQuotes(key) + "']"; |
|||
} |
|||
|
|||
|
|||
function escapeQuotes(str) { |
|||
return str.replace(SINGLE_QUOTE, '\\$&') |
|||
.replace(/\n/g, '\\n') |
|||
.replace(/\r/g, '\\r') |
|||
.replace(/\f/g, '\\f') |
|||
.replace(/\t/g, '\\t'); |
|||
} |
|||
|
|||
|
|||
function varOccurences(str, dataVar) { |
|||
dataVar += '[^0-9]'; |
|||
var matches = str.match(new RegExp(dataVar, 'g')); |
|||
return matches ? matches.length : 0; |
|||
} |
|||
|
|||
|
|||
function varReplace(str, dataVar, expr) { |
|||
dataVar += '([^0-9])'; |
|||
expr = expr.replace(/\$/g, '$$$$'); |
|||
return str.replace(new RegExp(dataVar, 'g'), expr + '$1'); |
|||
} |
|||
|
|||
|
|||
function schemaHasRules(schema, rules) { |
|||
if (typeof schema == 'boolean') return !schema; |
|||
for (var key in schema) if (rules[key]) return true; |
|||
} |
|||
|
|||
|
|||
function schemaHasRulesExcept(schema, rules, exceptKeyword) { |
|||
if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not'; |
|||
for (var key in schema) if (key != exceptKeyword && rules[key]) return true; |
|||
} |
|||
|
|||
|
|||
function schemaUnknownRules(schema, rules) { |
|||
if (typeof schema == 'boolean') return; |
|||
for (var key in schema) if (!rules[key]) return key; |
|||
} |
|||
|
|||
|
|||
function toQuotedString(str) { |
|||
return '\'' + escapeQuotes(str) + '\''; |
|||
} |
|||
|
|||
|
|||
function getPathExpr(currentPath, expr, jsonPointers, isNumber) { |
|||
var path = jsonPointers // false by default
|
|||
? '\'/\' + ' + expr + (isNumber ? '' : '.replace(/~/g, \'~0\').replace(/\\//g, \'~1\')') |
|||
: (isNumber ? '\'[\' + ' + expr + ' + \']\'' : '\'[\\\'\' + ' + expr + ' + \'\\\']\''); |
|||
return joinPaths(currentPath, path); |
|||
} |
|||
|
|||
|
|||
function getPath(currentPath, prop, jsonPointers) { |
|||
var path = jsonPointers // false by default
|
|||
? toQuotedString('/' + escapeJsonPointer(prop)) |
|||
: toQuotedString(getProperty(prop)); |
|||
return joinPaths(currentPath, path); |
|||
} |
|||
|
|||
|
|||
var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; |
|||
var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; |
|||
function getData($data, lvl, paths) { |
|||
var up, jsonPointer, data, matches; |
|||
if ($data === '') return 'rootData'; |
|||
if ($data[0] == '/') { |
|||
if (!JSON_POINTER.test($data)) throw new Error('Invalid JSON-pointer: ' + $data); |
|||
jsonPointer = $data; |
|||
data = 'rootData'; |
|||
} else { |
|||
matches = $data.match(RELATIVE_JSON_POINTER); |
|||
if (!matches) throw new Error('Invalid JSON-pointer: ' + $data); |
|||
up = +matches[1]; |
|||
jsonPointer = matches[2]; |
|||
if (jsonPointer == '#') { |
|||
if (up >= lvl) throw new Error('Cannot access property/index ' + up + ' levels up, current level is ' + lvl); |
|||
return paths[lvl - up]; |
|||
} |
|||
|
|||
if (up > lvl) throw new Error('Cannot access data ' + up + ' levels up, current level is ' + lvl); |
|||
data = 'data' + ((lvl - up) || ''); |
|||
if (!jsonPointer) return data; |
|||
} |
|||
|
|||
var expr = data; |
|||
var segments = jsonPointer.split('/'); |
|||
for (var i=0; i<segments.length; i++) { |
|||
var segment = segments[i]; |
|||
if (segment) { |
|||
data += getProperty(unescapeJsonPointer(segment)); |
|||
expr += ' && ' + data; |
|||
} |
|||
} |
|||
return expr; |
|||
} |
|||
|
|||
|
|||
function joinPaths (a, b) { |
|||
if (a == '""') return b; |
|||
return (a + ' + ' + b).replace(/([^\\])' \+ '/g, '$1'); |
|||
} |
|||
|
|||
|
|||
function unescapeFragment(str) { |
|||
return unescapeJsonPointer(decodeURIComponent(str)); |
|||
} |
|||
|
|||
|
|||
function escapeFragment(str) { |
|||
return encodeURIComponent(escapeJsonPointer(str)); |
|||
} |
|||
|
|||
|
|||
function escapeJsonPointer(str) { |
|||
return str.replace(/~/g, '~0').replace(/\//g, '~1'); |
|||
} |
|||
|
|||
|
|||
function unescapeJsonPointer(str) { |
|||
return str.replace(/~1/g, '/').replace(/~0/g, '~'); |
|||
} |
|||
@ -1,49 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var KEYWORDS = [ |
|||
'multipleOf', |
|||
'maximum', |
|||
'exclusiveMaximum', |
|||
'minimum', |
|||
'exclusiveMinimum', |
|||
'maxLength', |
|||
'minLength', |
|||
'pattern', |
|||
'additionalItems', |
|||
'maxItems', |
|||
'minItems', |
|||
'uniqueItems', |
|||
'maxProperties', |
|||
'minProperties', |
|||
'required', |
|||
'additionalProperties', |
|||
'enum', |
|||
'format', |
|||
'const' |
|||
]; |
|||
|
|||
module.exports = function (metaSchema, keywordsJsonPointers) { |
|||
for (var i=0; i<keywordsJsonPointers.length; i++) { |
|||
metaSchema = JSON.parse(JSON.stringify(metaSchema)); |
|||
var segments = keywordsJsonPointers[i].split('/'); |
|||
var keywords = metaSchema; |
|||
var j; |
|||
for (j=1; j<segments.length; j++) |
|||
keywords = keywords[segments[j]]; |
|||
|
|||
for (j=0; j<KEYWORDS.length; j++) { |
|||
var key = KEYWORDS[j]; |
|||
var schema = keywords[key]; |
|||
if (schema) { |
|||
keywords[key] = { |
|||
anyOf: [ |
|||
schema, |
|||
{ $ref: 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' } |
|||
] |
|||
}; |
|||
} |
|||
} |
|||
} |
|||
|
|||
return metaSchema; |
|||
}; |
|||
@ -1,37 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var metaSchema = require('./refs/json-schema-draft-07.json'); |
|||
|
|||
module.exports = { |
|||
$id: 'https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js', |
|||
definitions: { |
|||
simpleTypes: metaSchema.definitions.simpleTypes |
|||
}, |
|||
type: 'object', |
|||
dependencies: { |
|||
schema: ['validate'], |
|||
$data: ['validate'], |
|||
statements: ['inline'], |
|||
valid: {not: {required: ['macro']}} |
|||
}, |
|||
properties: { |
|||
type: metaSchema.properties.type, |
|||
schema: {type: 'boolean'}, |
|||
statements: {type: 'boolean'}, |
|||
dependencies: { |
|||
type: 'array', |
|||
items: {type: 'string'} |
|||
}, |
|||
metaSchema: {type: 'object'}, |
|||
modifying: {type: 'boolean'}, |
|||
valid: {type: 'boolean'}, |
|||
$data: {type: 'boolean'}, |
|||
async: {type: 'boolean'}, |
|||
errors: { |
|||
anyOf: [ |
|||
{type: 'boolean'}, |
|||
{const: 'full'} |
|||
] |
|||
} |
|||
} |
|||
}; |
|||
@ -1,113 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{## def.setExclusiveLimit: |
|||
$exclusive = true; |
|||
$errorKeyword = $exclusiveKeyword; |
|||
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|||
#}} |
|||
|
|||
{{ |
|||
var $isMax = $keyword == 'maximum' |
|||
, $exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum' |
|||
, $schemaExcl = it.schema[$exclusiveKeyword] |
|||
, $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data |
|||
, $op = $isMax ? '<' : '>' |
|||
, $notOp = $isMax ? '>' : '<' |
|||
, $errorKeyword = undefined; |
|||
|
|||
if (!($isData || typeof $schema == 'number' || $schema === undefined)) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
if (!($isDataExcl || $schemaExcl === undefined |
|||
|| typeof $schemaExcl == 'number' |
|||
|| typeof $schemaExcl == 'boolean')) { |
|||
throw new Error($exclusiveKeyword + ' must be number or boolean'); |
|||
} |
|||
}} |
|||
|
|||
{{? $isDataExcl }} |
|||
{{ |
|||
var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr) |
|||
, $exclusive = 'exclusive' + $lvl |
|||
, $exclType = 'exclType' + $lvl |
|||
, $exclIsNumber = 'exclIsNumber' + $lvl |
|||
, $opExpr = 'op' + $lvl |
|||
, $opStr = '\' + ' + $opExpr + ' + \''; |
|||
}} |
|||
var schemaExcl{{=$lvl}} = {{=$schemaValueExcl}}; |
|||
{{ $schemaValueExcl = 'schemaExcl' + $lvl; }} |
|||
|
|||
var {{=$exclusive}}; |
|||
var {{=$exclType}} = typeof {{=$schemaValueExcl}}; |
|||
if ({{=$exclType}} != 'boolean' && {{=$exclType}} != 'undefined' && {{=$exclType}} != 'number') { |
|||
{{ var $errorKeyword = $exclusiveKeyword; }} |
|||
{{# def.error:'_exclusiveLimit' }} |
|||
} else if ({{# def.$dataNotType:'number' }} |
|||
{{=$exclType}} == 'number' |
|||
? ( |
|||
({{=$exclusive}} = {{=$schemaValue}} === undefined || {{=$schemaValueExcl}} {{=$op}}= {{=$schemaValue}}) |
|||
? {{=$data}} {{=$notOp}}= {{=$schemaValueExcl}} |
|||
: {{=$data}} {{=$notOp}} {{=$schemaValue}} |
|||
) |
|||
: ( |
|||
({{=$exclusive}} = {{=$schemaValueExcl}} === true) |
|||
? {{=$data}} {{=$notOp}}= {{=$schemaValue}} |
|||
: {{=$data}} {{=$notOp}} {{=$schemaValue}} |
|||
) |
|||
|| {{=$data}} !== {{=$data}}) { |
|||
var op{{=$lvl}} = {{=$exclusive}} ? '{{=$op}}' : '{{=$op}}='; |
|||
{{ |
|||
if ($schema === undefined) { |
|||
$errorKeyword = $exclusiveKeyword; |
|||
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|||
$schemaValue = $schemaValueExcl; |
|||
$isData = $isDataExcl; |
|||
} |
|||
}} |
|||
{{??}} |
|||
{{ |
|||
var $exclIsNumber = typeof $schemaExcl == 'number' |
|||
, $opStr = $op; /*used in error*/ |
|||
}} |
|||
|
|||
{{? $exclIsNumber && $isData }} |
|||
{{ var $opExpr = '\'' + $opStr + '\''; /*used in error*/ }} |
|||
if ({{# def.$dataNotType:'number' }} |
|||
( {{=$schemaValue}} === undefined |
|||
|| {{=$schemaExcl}} {{=$op}}= {{=$schemaValue}} |
|||
? {{=$data}} {{=$notOp}}= {{=$schemaExcl}} |
|||
: {{=$data}} {{=$notOp}} {{=$schemaValue}} ) |
|||
|| {{=$data}} !== {{=$data}}) { |
|||
{{??}} |
|||
{{ |
|||
if ($exclIsNumber && $schema === undefined) { |
|||
{{# def.setExclusiveLimit }} |
|||
$schemaValue = $schemaExcl; |
|||
$notOp += '='; |
|||
} else { |
|||
if ($exclIsNumber) |
|||
$schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema); |
|||
|
|||
if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) { |
|||
{{# def.setExclusiveLimit }} |
|||
$notOp += '='; |
|||
} else { |
|||
$exclusive = false; |
|||
$opStr += '='; |
|||
} |
|||
} |
|||
|
|||
var $opExpr = '\'' + $opStr + '\''; /*used in error*/ |
|||
}} |
|||
|
|||
if ({{# def.$dataNotType:'number' }} |
|||
{{=$data}} {{=$notOp}} {{=$schemaValue}} |
|||
|| {{=$data}} !== {{=$data}}) { |
|||
{{?}} |
|||
{{?}} |
|||
{{ $errorKeyword = $errorKeyword || $keyword; }} |
|||
{{# def.error:'_limit' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,12 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{# def.numberKeyword }} |
|||
|
|||
{{ var $op = $keyword == 'maxItems' ? '>' : '<'; }} |
|||
if ({{# def.$dataNotType:'number' }} {{=$data}}.length {{=$op}} {{=$schemaValue}}) { |
|||
{{ var $errorKeyword = $keyword; }} |
|||
{{# def.error:'_limitItems' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,12 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{# def.numberKeyword }} |
|||
|
|||
{{ var $op = $keyword == 'maxLength' ? '>' : '<'; }} |
|||
if ({{# def.$dataNotType:'number' }} {{# def.strLength }} {{=$op}} {{=$schemaValue}}) { |
|||
{{ var $errorKeyword = $keyword; }} |
|||
{{# def.error:'_limitLength' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,12 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{# def.numberKeyword }} |
|||
|
|||
{{ var $op = $keyword == 'maxProperties' ? '>' : '<'; }} |
|||
if ({{# def.$dataNotType:'number' }} Object.keys({{=$data}}).length {{=$op}} {{=$schemaValue}}) { |
|||
{{ var $errorKeyword = $keyword; }} |
|||
{{# def.error:'_limitProperties' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,32 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
{{ |
|||
var $currentBaseId = $it.baseId |
|||
, $allSchemasEmpty = true; |
|||
}} |
|||
|
|||
{{~ $schema:$sch:$i }} |
|||
{{? {{# def.nonEmptySchema:$sch }} }} |
|||
{{ |
|||
$allSchemasEmpty = false; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
}} |
|||
|
|||
{{# def.insertSubschemaCode }} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} |
|||
{{~}} |
|||
|
|||
{{? $breakOnError }} |
|||
{{? $allSchemasEmpty }} |
|||
if (true) { |
|||
{{??}} |
|||
{{= $closingBraces.slice(0,-1) }} |
|||
{{?}} |
|||
{{?}} |
|||
@ -1,46 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
{{ |
|||
var $noEmptySchema = $schema.every(function($sch) { |
|||
return {{# def.nonEmptySchema:$sch }}; |
|||
}); |
|||
}} |
|||
{{? $noEmptySchema }} |
|||
{{ var $currentBaseId = $it.baseId; }} |
|||
var {{=$errs}} = errors; |
|||
var {{=$valid}} = false; |
|||
|
|||
{{# def.setCompositeRule }} |
|||
|
|||
{{~ $schema:$sch:$i }} |
|||
{{ |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
}} |
|||
|
|||
{{# def.insertSubschemaCode }} |
|||
|
|||
{{=$valid}} = {{=$valid}} || {{=$nextValid}}; |
|||
|
|||
if (!{{=$valid}}) { |
|||
{{ $closingBraces += '}'; }} |
|||
{{~}} |
|||
|
|||
{{# def.resetCompositeRule }} |
|||
|
|||
{{= $closingBraces }} |
|||
|
|||
if (!{{=$valid}}) { |
|||
{{# def.extraError:'anyOf' }} |
|||
} else { |
|||
{{# def.resetErrors }} |
|||
{{? it.opts.allErrors }} } {{?}} |
|||
{{??}} |
|||
{{? $breakOnError }} |
|||
if (true) { |
|||
{{?}} |
|||
{{?}} |
|||
@ -1,51 +0,0 @@ |
|||
{{## def.coerceType: |
|||
{{ |
|||
var $dataType = 'dataType' + $lvl |
|||
, $coerced = 'coerced' + $lvl; |
|||
}} |
|||
var {{=$dataType}} = typeof {{=$data}}; |
|||
var {{=$coerced}} = undefined; |
|||
|
|||
{{? it.opts.coerceTypes == 'array' }} |
|||
if ({{=$dataType}} == 'object' && Array.isArray({{=$data}}) && {{=$data}}.length == 1) { |
|||
{{=$data}} = {{=$data}}[0]; |
|||
{{=$dataType}} = typeof {{=$data}}; |
|||
if ({{=it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers)}}) {{=$coerced}} = {{=$data}}; |
|||
} |
|||
{{?}} |
|||
|
|||
if ({{=$coerced}} !== undefined) ; |
|||
{{~ $coerceToTypes:$type:$i }} |
|||
{{? $type == 'string' }} |
|||
else if ({{=$dataType}} == 'number' || {{=$dataType}} == 'boolean') |
|||
{{=$coerced}} = '' + {{=$data}}; |
|||
else if ({{=$data}} === null) {{=$coerced}} = ''; |
|||
{{?? $type == 'number' || $type == 'integer' }} |
|||
else if ({{=$dataType}} == 'boolean' || {{=$data}} === null |
|||
|| ({{=$dataType}} == 'string' && {{=$data}} && {{=$data}} == +{{=$data}} |
|||
{{? $type == 'integer' }} && !({{=$data}} % 1){{?}})) |
|||
{{=$coerced}} = +{{=$data}}; |
|||
{{?? $type == 'boolean' }} |
|||
else if ({{=$data}} === 'false' || {{=$data}} === 0 || {{=$data}} === null) |
|||
{{=$coerced}} = false; |
|||
else if ({{=$data}} === 'true' || {{=$data}} === 1) |
|||
{{=$coerced}} = true; |
|||
{{?? $type == 'null' }} |
|||
else if ({{=$data}} === '' || {{=$data}} === 0 || {{=$data}} === false) |
|||
{{=$coerced}} = null; |
|||
{{?? it.opts.coerceTypes == 'array' && $type == 'array' }} |
|||
else if ({{=$dataType}} == 'string' || {{=$dataType}} == 'number' || {{=$dataType}} == 'boolean' || {{=$data}} == null) |
|||
{{=$coerced}} = [{{=$data}}]; |
|||
{{?}} |
|||
{{~}} |
|||
else { |
|||
{{# def.error:'type' }} |
|||
} |
|||
|
|||
if ({{=$coerced}} !== undefined) { |
|||
{{# def.setParentData }} |
|||
{{=$data}} = {{=$coerced}}; |
|||
{{? !$dataLvl }}if ({{=$parentData}} !== undefined){{?}} |
|||
{{=$parentData}}[{{=$parentDataProperty}}] = {{=$coerced}}; |
|||
} |
|||
#}} |
|||
@ -1,9 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.setupKeyword }} |
|||
|
|||
{{ var $comment = it.util.toQuotedString($schema); }} |
|||
{{? it.opts.$comment === true }} |
|||
console.log({{=$comment}}); |
|||
{{?? typeof it.opts.$comment == 'function' }} |
|||
self._opts.$comment({{=$comment}}, {{=it.util.toQuotedString($errSchemaPath)}}, validate.root.schema); |
|||
{{?}} |
|||
@ -1,11 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{? !$isData }} |
|||
var schema{{=$lvl}} = validate.schema{{=$schemaPath}}; |
|||
{{?}} |
|||
var {{=$valid}} = equal({{=$data}}, schema{{=$lvl}}); |
|||
{{# def.checkError:'const' }} |
|||
{{? $breakOnError }} else { {{?}} |
|||
@ -1,55 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
|
|||
{{ |
|||
var $idx = 'i' + $lvl |
|||
, $dataNxt = $it.dataLevel = it.dataLevel + 1 |
|||
, $nextData = 'data' + $dataNxt |
|||
, $currentBaseId = it.baseId |
|||
, $nonEmptySchema = {{# def.nonEmptySchema:$schema }}; |
|||
}} |
|||
|
|||
var {{=$errs}} = errors; |
|||
var {{=$valid}}; |
|||
|
|||
{{? $nonEmptySchema }} |
|||
{{# def.setCompositeRule }} |
|||
|
|||
{{ |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
}} |
|||
|
|||
var {{=$nextValid}} = false; |
|||
|
|||
for (var {{=$idx}} = 0; {{=$idx}} < {{=$data}}.length; {{=$idx}}++) { |
|||
{{ |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|||
var $passData = $data + '[' + $idx + ']'; |
|||
$it.dataPathArr[$dataNxt] = $idx; |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
|
|||
if ({{=$nextValid}}) break; |
|||
} |
|||
|
|||
{{# def.resetCompositeRule }} |
|||
{{= $closingBraces }} |
|||
|
|||
if (!{{=$nextValid}}) { |
|||
{{??}} |
|||
if ({{=$data}}.length == 0) { |
|||
{{?}} |
|||
|
|||
{{# def.error:'contains' }} |
|||
} else { |
|||
{{? $nonEmptySchema }} |
|||
{{# def.resetErrors }} |
|||
{{?}} |
|||
{{? it.opts.allErrors }} } {{?}} |
|||
@ -1,191 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{ |
|||
var $rule = this |
|||
, $definition = 'definition' + $lvl |
|||
, $rDef = $rule.definition |
|||
, $closingBraces = ''; |
|||
var $validate = $rDef.validate; |
|||
var $compile, $inline, $macro, $ruleValidate, $validateCode; |
|||
}} |
|||
|
|||
{{? $isData && $rDef.$data }} |
|||
{{ |
|||
$validateCode = 'keywordValidate' + $lvl; |
|||
var $validateSchema = $rDef.validateSchema; |
|||
}} |
|||
var {{=$definition}} = RULES.custom['{{=$keyword}}'].definition; |
|||
var {{=$validateCode}} = {{=$definition}}.validate; |
|||
{{??}} |
|||
{{ |
|||
$ruleValidate = it.useCustomRule($rule, $schema, it.schema, it); |
|||
if (!$ruleValidate) return; |
|||
$schemaValue = 'validate.schema' + $schemaPath; |
|||
$validateCode = $ruleValidate.code; |
|||
$compile = $rDef.compile; |
|||
$inline = $rDef.inline; |
|||
$macro = $rDef.macro; |
|||
}} |
|||
{{?}} |
|||
|
|||
{{ |
|||
var $ruleErrs = $validateCode + '.errors' |
|||
, $i = 'i' + $lvl |
|||
, $ruleErr = 'ruleErr' + $lvl |
|||
, $asyncKeyword = $rDef.async; |
|||
|
|||
if ($asyncKeyword && !it.async) |
|||
throw new Error('async keyword in sync schema'); |
|||
}} |
|||
|
|||
|
|||
{{? !($inline || $macro) }}{{=$ruleErrs}} = null;{{?}} |
|||
var {{=$errs}} = errors; |
|||
var {{=$valid}}; |
|||
|
|||
{{## def.callRuleValidate: |
|||
{{=$validateCode}}.call( |
|||
{{? it.opts.passContext }}this{{??}}self{{?}} |
|||
{{? $compile || $rDef.schema === false }} |
|||
, {{=$data}} |
|||
{{??}} |
|||
, {{=$schemaValue}} |
|||
, {{=$data}} |
|||
, validate.schema{{=it.schemaPath}} |
|||
{{?}} |
|||
, {{# def.dataPath }} |
|||
{{# def.passParentData }} |
|||
, rootData |
|||
) |
|||
#}} |
|||
|
|||
{{## def.extendErrors:_inline: |
|||
for (var {{=$i}}={{=$errs}}; {{=$i}}<errors; {{=$i}}++) { |
|||
var {{=$ruleErr}} = vErrors[{{=$i}}]; |
|||
if ({{=$ruleErr}}.dataPath === undefined) |
|||
{{=$ruleErr}}.dataPath = (dataPath || '') + {{= it.errorPath }}; |
|||
{{# _inline ? 'if (\{\{=$ruleErr\}\}.schemaPath === undefined) {' : '' }} |
|||
{{=$ruleErr}}.schemaPath = "{{=$errSchemaPath}}"; |
|||
{{# _inline ? '}' : '' }} |
|||
{{? it.opts.verbose }} |
|||
{{=$ruleErr}}.schema = {{=$schemaValue}}; |
|||
{{=$ruleErr}}.data = {{=$data}}; |
|||
{{?}} |
|||
} |
|||
#}} |
|||
|
|||
|
|||
{{? $isData && $rDef.$data }} |
|||
{{ $closingBraces += '}'; }} |
|||
if ({{=$schemaValue}} === undefined) { |
|||
{{=$valid}} = true; |
|||
} else { |
|||
{{? $validateSchema }} |
|||
{{ $closingBraces += '}'; }} |
|||
{{=$valid}} = {{=$definition}}.validateSchema({{=$schemaValue}}); |
|||
if ({{=$valid}}) { |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? $inline }} |
|||
{{? $rDef.statements }} |
|||
{{= $ruleValidate.validate }} |
|||
{{??}} |
|||
{{=$valid}} = {{= $ruleValidate.validate }}; |
|||
{{?}} |
|||
{{?? $macro }} |
|||
{{# def.setupNextLevel }} |
|||
{{ |
|||
$it.schema = $ruleValidate.validate; |
|||
$it.schemaPath = ''; |
|||
}} |
|||
{{# def.setCompositeRule }} |
|||
{{ var $code = it.validate($it).replace(/validate\.schema/g, $validateCode); }} |
|||
{{# def.resetCompositeRule }} |
|||
{{= $code }} |
|||
{{??}} |
|||
{{# def.beginDefOut}} |
|||
{{# def.callRuleValidate }} |
|||
{{# def.storeDefOut:def_callRuleValidate }} |
|||
|
|||
{{? $rDef.errors === false }} |
|||
{{=$valid}} = {{? $asyncKeyword }}await {{?}}{{= def_callRuleValidate }}; |
|||
{{??}} |
|||
{{? $asyncKeyword }} |
|||
{{ $ruleErrs = 'customErrors' + $lvl; }} |
|||
var {{=$ruleErrs}} = null; |
|||
try { |
|||
{{=$valid}} = await {{= def_callRuleValidate }}; |
|||
} catch (e) { |
|||
{{=$valid}} = false; |
|||
if (e instanceof ValidationError) {{=$ruleErrs}} = e.errors; |
|||
else throw e; |
|||
} |
|||
{{??}} |
|||
{{=$ruleErrs}} = null; |
|||
{{=$valid}} = {{= def_callRuleValidate }}; |
|||
{{?}} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? $rDef.modifying }} |
|||
if ({{=$parentData}}) {{=$data}} = {{=$parentData}}[{{=$parentDataProperty}}]; |
|||
{{?}} |
|||
|
|||
{{= $closingBraces }} |
|||
|
|||
{{## def.notValidationResult: |
|||
{{? $rDef.valid === undefined }} |
|||
!{{? $macro }}{{=$nextValid}}{{??}}{{=$valid}}{{?}} |
|||
{{??}} |
|||
{{= !$rDef.valid }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
{{? $rDef.valid }} |
|||
{{? $breakOnError }} if (true) { {{?}} |
|||
{{??}} |
|||
if ({{# def.notValidationResult }}) { |
|||
{{ $errorKeyword = $rule.keyword; }} |
|||
{{# def.beginDefOut}} |
|||
{{# def.error:'custom' }} |
|||
{{# def.storeDefOut:def_customError }} |
|||
|
|||
{{? $inline }} |
|||
{{? $rDef.errors }} |
|||
{{? $rDef.errors != 'full' }} |
|||
{{# def.extendErrors:true }} |
|||
{{?}} |
|||
{{??}} |
|||
{{? $rDef.errors === false}} |
|||
{{= def_customError }} |
|||
{{??}} |
|||
if ({{=$errs}} == errors) { |
|||
{{= def_customError }} |
|||
} else { |
|||
{{# def.extendErrors:true }} |
|||
} |
|||
{{?}} |
|||
{{?}} |
|||
{{?? $macro }} |
|||
{{# def.extraError:'custom' }} |
|||
{{??}} |
|||
{{? $rDef.errors === false}} |
|||
{{= def_customError }} |
|||
{{??}} |
|||
if (Array.isArray({{=$ruleErrs}})) { |
|||
if (vErrors === null) vErrors = {{=$ruleErrs}}; |
|||
else vErrors = vErrors.concat({{=$ruleErrs}}); |
|||
errors = vErrors.length; |
|||
{{# def.extendErrors:false }} |
|||
} else { |
|||
{{= def_customError }} |
|||
} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
} {{? $breakOnError }} else { {{?}} |
|||
{{?}} |
|||
@ -1,47 +0,0 @@ |
|||
{{## def.assignDefault: |
|||
{{? it.compositeRule }} |
|||
{{ |
|||
if (it.opts.strictDefaults) { |
|||
var $defaultMsg = 'default is ignored for: ' + $passData; |
|||
if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
|||
else throw new Error($defaultMsg); |
|||
} |
|||
}} |
|||
{{??}} |
|||
if ({{=$passData}} === undefined |
|||
{{? it.opts.useDefaults == 'empty' }} |
|||
|| {{=$passData}} === null |
|||
|| {{=$passData}} === '' |
|||
{{?}} |
|||
) |
|||
{{=$passData}} = {{? it.opts.useDefaults == 'shared' }} |
|||
{{= it.useDefault($sch.default) }} |
|||
{{??}} |
|||
{{= JSON.stringify($sch.default) }} |
|||
{{?}}; |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.defaultProperties: |
|||
{{ |
|||
var $schema = it.schema.properties |
|||
, $schemaKeys = Object.keys($schema); }} |
|||
{{~ $schemaKeys:$propertyKey }} |
|||
{{ var $sch = $schema[$propertyKey]; }} |
|||
{{? $sch.default !== undefined }} |
|||
{{ var $passData = $data + it.util.getProperty($propertyKey); }} |
|||
{{# def.assignDefault }} |
|||
{{?}} |
|||
{{~}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.defaultItems: |
|||
{{~ it.schema.items:$sch:$i }} |
|||
{{? $sch.default !== undefined }} |
|||
{{ var $passData = $data + '[' + $i + ']'; }} |
|||
{{# def.assignDefault }} |
|||
{{?}} |
|||
{{~}} |
|||
#}} |
|||
@ -1,203 +0,0 @@ |
|||
{{## def.setupKeyword: |
|||
{{ |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
|
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.setCompositeRule: |
|||
{{ |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.resetCompositeRule: |
|||
{{ it.compositeRule = $it.compositeRule = $wasComposite; }} |
|||
#}} |
|||
|
|||
|
|||
{{## def.setupNextLevel: |
|||
{{ |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.ifValid: |
|||
{{? $breakOnError }} |
|||
if ({{=$valid}}) { |
|||
{{ $closingBraces += '}'; }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.ifResultValid: |
|||
{{? $breakOnError }} |
|||
if ({{=$nextValid}}) { |
|||
{{ $closingBraces += '}'; }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.elseIfValid: |
|||
{{? $breakOnError }} |
|||
{{ $closingBraces += '}'; }} |
|||
else { |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.nonEmptySchema:_schema: |
|||
(it.opts.strictKeywords |
|||
? (typeof _schema == 'object' && Object.keys(_schema).length > 0) |
|||
|| _schema === false |
|||
: it.util.schemaHasRules(_schema, it.RULES.all)) |
|||
#}} |
|||
|
|||
|
|||
{{## def.strLength: |
|||
{{? it.opts.unicode === false }} |
|||
{{=$data}}.length |
|||
{{??}} |
|||
ucs2length({{=$data}}) |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.willOptimize: |
|||
it.util.varOccurences($code, $nextData) < 2 |
|||
#}} |
|||
|
|||
|
|||
{{## def.generateSubschemaCode: |
|||
{{ |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.insertSubschemaCode: |
|||
{{= it.validate($it) }} |
|||
{{ $it.baseId = $currentBaseId; }} |
|||
#}} |
|||
|
|||
|
|||
{{## def._optimizeValidate: |
|||
it.util.varReplace($code, $nextData, $passData) |
|||
#}} |
|||
|
|||
|
|||
{{## def.optimizeValidate: |
|||
{{? {{# def.willOptimize}} }} |
|||
{{= {{# def._optimizeValidate }} }} |
|||
{{??}} |
|||
var {{=$nextData}} = {{=$passData}}; |
|||
{{= $code }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.$data: |
|||
{{ |
|||
var $isData = it.opts.$data && $schema && $schema.$data |
|||
, $schemaValue; |
|||
}} |
|||
{{? $isData }} |
|||
var schema{{=$lvl}} = {{= it.util.getData($schema.$data, $dataLvl, it.dataPathArr) }}; |
|||
{{ $schemaValue = 'schema' + $lvl; }} |
|||
{{??}} |
|||
{{ $schemaValue = $schema; }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.$dataNotType:_type: |
|||
{{?$isData}} ({{=$schemaValue}} !== undefined && typeof {{=$schemaValue}} != _type) || {{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.check$dataIsArray: |
|||
if (schema{{=$lvl}} === undefined) {{=$valid}} = true; |
|||
else if (!Array.isArray(schema{{=$lvl}})) {{=$valid}} = false; |
|||
else { |
|||
#}} |
|||
|
|||
|
|||
{{## def.numberKeyword: |
|||
{{? !($isData || typeof $schema == 'number') }} |
|||
{{ throw new Error($keyword + ' must be number'); }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.beginDefOut: |
|||
{{ |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.storeDefOut:_variable: |
|||
{{ |
|||
var _variable = out; |
|||
out = $$outStack.pop(); |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.dataPath:(dataPath || ''){{? it.errorPath != '""'}} + {{= it.errorPath }}{{?}}#}} |
|||
|
|||
{{## def.setParentData: |
|||
{{ |
|||
var $parentData = $dataLvl ? 'data' + (($dataLvl-1)||'') : 'parentData' |
|||
, $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|||
}} |
|||
#}} |
|||
|
|||
{{## def.passParentData: |
|||
{{# def.setParentData }} |
|||
, {{= $parentData }} |
|||
, {{= $parentDataProperty }} |
|||
#}} |
|||
|
|||
|
|||
{{## def.iterateProperties: |
|||
{{? $ownProperties }} |
|||
{{=$dataProperties}} = {{=$dataProperties}} || Object.keys({{=$data}}); |
|||
for (var {{=$idx}}=0; {{=$idx}}<{{=$dataProperties}}.length; {{=$idx}}++) { |
|||
var {{=$key}} = {{=$dataProperties}}[{{=$idx}}]; |
|||
{{??}} |
|||
for (var {{=$key}} in {{=$data}}) { |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.noPropertyInData: |
|||
{{=$useData}} === undefined |
|||
{{? $ownProperties }} |
|||
|| !{{# def.isOwnProperty }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.isOwnProperty: |
|||
Object.prototype.hasOwnProperty.call({{=$data}}, '{{=it.util.escapeQuotes($propertyKey)}}') |
|||
#}} |
|||
@ -1,79 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.missing }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
|
|||
{{## def.propertyInData: |
|||
{{=$data}}{{= it.util.getProperty($property) }} !== undefined |
|||
{{? $ownProperties }} |
|||
&& Object.prototype.hasOwnProperty.call({{=$data}}, '{{=it.util.escapeQuotes($property)}}') |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{ |
|||
var $schemaDeps = {} |
|||
, $propertyDeps = {} |
|||
, $ownProperties = it.opts.ownProperties; |
|||
|
|||
for ($property in $schema) { |
|||
if ($property == '__proto__') continue; |
|||
var $sch = $schema[$property]; |
|||
var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps; |
|||
$deps[$property] = $sch; |
|||
} |
|||
}} |
|||
|
|||
var {{=$errs}} = errors; |
|||
|
|||
{{ var $currentErrorPath = it.errorPath; }} |
|||
|
|||
var missing{{=$lvl}}; |
|||
{{ for (var $property in $propertyDeps) { }} |
|||
{{ $deps = $propertyDeps[$property]; }} |
|||
{{? $deps.length }} |
|||
if ({{# def.propertyInData }} |
|||
{{? $breakOnError }} |
|||
&& ({{# def.checkMissingProperty:$deps }})) { |
|||
{{# def.errorMissingProperty:'dependencies' }} |
|||
{{??}} |
|||
) { |
|||
{{~ $deps:$propertyKey }} |
|||
{{# def.allErrorsMissingProperty:'dependencies' }} |
|||
{{~}} |
|||
{{?}} |
|||
} {{# def.elseIfValid }} |
|||
{{?}} |
|||
{{ } }} |
|||
|
|||
{{ |
|||
it.errorPath = $currentErrorPath; |
|||
var $currentBaseId = $it.baseId; |
|||
}} |
|||
|
|||
|
|||
{{ for (var $property in $schemaDeps) { }} |
|||
{{ var $sch = $schemaDeps[$property]; }} |
|||
{{? {{# def.nonEmptySchema:$sch }} }} |
|||
{{=$nextValid}} = true; |
|||
|
|||
if ({{# def.propertyInData }}) { |
|||
{{ |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + it.util.getProperty($property); |
|||
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property); |
|||
}} |
|||
|
|||
{{# def.insertSubschemaCode }} |
|||
} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} |
|||
{{ } }} |
|||
|
|||
{{? $breakOnError }} |
|||
{{= $closingBraces }} |
|||
if ({{=$errs}} == errors) { |
|||
{{?}} |
|||
@ -1,30 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{ |
|||
var $i = 'i' + $lvl |
|||
, $vSchema = 'schema' + $lvl; |
|||
}} |
|||
|
|||
{{? !$isData }} |
|||
var {{=$vSchema}} = validate.schema{{=$schemaPath}}; |
|||
{{?}} |
|||
var {{=$valid}}; |
|||
|
|||
{{?$isData}}{{# def.check$dataIsArray }}{{?}} |
|||
|
|||
{{=$valid}} = false; |
|||
|
|||
for (var {{=$i}}=0; {{=$i}}<{{=$vSchema}}.length; {{=$i}}++) |
|||
if (equal({{=$data}}, {{=$vSchema}}[{{=$i}}])) { |
|||
{{=$valid}} = true; |
|||
break; |
|||
} |
|||
|
|||
{{? $isData }} } {{?}} |
|||
|
|||
{{# def.checkError:'enum' }} |
|||
|
|||
{{? $breakOnError }} else { {{?}} |
|||
@ -1,194 +0,0 @@ |
|||
{{# def.definitions }} |
|||
|
|||
{{## def._error:_rule: |
|||
{{ 'istanbul ignore else'; }} |
|||
{{? it.createErrors !== false }} |
|||
{ |
|||
keyword: '{{= $errorKeyword || _rule }}' |
|||
, dataPath: (dataPath || '') + {{= it.errorPath }} |
|||
, schemaPath: {{=it.util.toQuotedString($errSchemaPath)}} |
|||
, params: {{# def._errorParams[_rule] }} |
|||
{{? it.opts.messages !== false }} |
|||
, message: {{# def._errorMessages[_rule] }} |
|||
{{?}} |
|||
{{? it.opts.verbose }} |
|||
, schema: {{# def._errorSchemas[_rule] }} |
|||
, parentSchema: validate.schema{{=it.schemaPath}} |
|||
, data: {{=$data}} |
|||
{{?}} |
|||
} |
|||
{{??}} |
|||
{} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def._addError:_rule: |
|||
if (vErrors === null) vErrors = [err]; |
|||
else vErrors.push(err); |
|||
errors++; |
|||
#}} |
|||
|
|||
|
|||
{{## def.addError:_rule: |
|||
var err = {{# def._error:_rule }}; |
|||
{{# def._addError:_rule }} |
|||
#}} |
|||
|
|||
|
|||
{{## def.error:_rule: |
|||
{{# def.beginDefOut}} |
|||
{{# def._error:_rule }} |
|||
{{# def.storeDefOut:__err }} |
|||
|
|||
{{? !it.compositeRule && $breakOnError }} |
|||
{{ 'istanbul ignore if'; }} |
|||
{{? it.async }} |
|||
throw new ValidationError([{{=__err}}]); |
|||
{{??}} |
|||
validate.errors = [{{=__err}}]; |
|||
return false; |
|||
{{?}} |
|||
{{??}} |
|||
var err = {{=__err}}; |
|||
{{# def._addError:_rule }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.extraError:_rule: |
|||
{{# def.addError:_rule}} |
|||
{{? !it.compositeRule && $breakOnError }} |
|||
{{ 'istanbul ignore if'; }} |
|||
{{? it.async }} |
|||
throw new ValidationError(vErrors); |
|||
{{??}} |
|||
validate.errors = vErrors; |
|||
return false; |
|||
{{?}} |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.checkError:_rule: |
|||
if (!{{=$valid}}) { |
|||
{{# def.error:_rule }} |
|||
} |
|||
#}} |
|||
|
|||
|
|||
{{## def.resetErrors: |
|||
errors = {{=$errs}}; |
|||
if (vErrors !== null) { |
|||
if ({{=$errs}}) vErrors.length = {{=$errs}}; |
|||
else vErrors = null; |
|||
} |
|||
#}} |
|||
|
|||
|
|||
{{## def.concatSchema:{{?$isData}}' + {{=$schemaValue}} + '{{??}}{{=$schema}}{{?}}#}} |
|||
{{## def.appendSchema:{{?$isData}}' + {{=$schemaValue}}{{??}}{{=$schemaValue}}'{{?}}#}} |
|||
{{## def.concatSchemaEQ:{{?$isData}}' + {{=$schemaValue}} + '{{??}}{{=it.util.escapeQuotes($schema)}}{{?}}#}} |
|||
|
|||
{{## def._errorMessages = { |
|||
'false schema': "'boolean schema is false'", |
|||
$ref: "'can\\\'t resolve reference {{=it.util.escapeQuotes($schema)}}'", |
|||
additionalItems: "'should NOT have more than {{=$schema.length}} items'", |
|||
additionalProperties: "'{{? it.opts._errorDataPathProperty }}is an invalid additional property{{??}}should NOT have additional properties{{?}}'", |
|||
anyOf: "'should match some schema in anyOf'", |
|||
const: "'should be equal to constant'", |
|||
contains: "'should contain a valid item'", |
|||
dependencies: "'should have {{? $deps.length == 1 }}property {{= it.util.escapeQuotes($deps[0]) }}{{??}}properties {{= it.util.escapeQuotes($deps.join(\", \")) }}{{?}} when property {{= it.util.escapeQuotes($property) }} is present'", |
|||
'enum': "'should be equal to one of the allowed values'", |
|||
format: "'should match format \"{{#def.concatSchemaEQ}}\"'", |
|||
'if': "'should match \"' + {{=$ifClause}} + '\" schema'", |
|||
_limit: "'should be {{=$opStr}} {{#def.appendSchema}}", |
|||
_exclusiveLimit: "'{{=$exclusiveKeyword}} should be boolean'", |
|||
_limitItems: "'should NOT have {{?$keyword=='maxItems'}}more{{??}}fewer{{?}} than {{#def.concatSchema}} items'", |
|||
_limitLength: "'should NOT be {{?$keyword=='maxLength'}}longer{{??}}shorter{{?}} than {{#def.concatSchema}} characters'", |
|||
_limitProperties:"'should NOT have {{?$keyword=='maxProperties'}}more{{??}}fewer{{?}} than {{#def.concatSchema}} properties'", |
|||
multipleOf: "'should be multiple of {{#def.appendSchema}}", |
|||
not: "'should NOT be valid'", |
|||
oneOf: "'should match exactly one schema in oneOf'", |
|||
pattern: "'should match pattern \"{{#def.concatSchemaEQ}}\"'", |
|||
propertyNames: "'property name \\'{{=$invalidName}}\\' is invalid'", |
|||
required: "'{{? it.opts._errorDataPathProperty }}is a required property{{??}}should have required property \\'{{=$missingProperty}}\\'{{?}}'", |
|||
type: "'should be {{? $typeIsArray }}{{= $typeSchema.join(\",\") }}{{??}}{{=$typeSchema}}{{?}}'", |
|||
uniqueItems: "'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)'", |
|||
custom: "'should pass \"{{=$rule.keyword}}\" keyword validation'", |
|||
patternRequired: "'should have property matching pattern \\'{{=$missingPattern}}\\''", |
|||
switch: "'should pass \"switch\" keyword validation'", |
|||
_formatLimit: "'should be {{=$opStr}} \"{{#def.concatSchemaEQ}}\"'", |
|||
_formatExclusiveLimit: "'{{=$exclusiveKeyword}} should be boolean'" |
|||
} #}} |
|||
|
|||
|
|||
{{## def.schemaRefOrVal: {{?$isData}}validate.schema{{=$schemaPath}}{{??}}{{=$schema}}{{?}} #}} |
|||
{{## def.schemaRefOrQS: {{?$isData}}validate.schema{{=$schemaPath}}{{??}}{{=it.util.toQuotedString($schema)}}{{?}} #}} |
|||
|
|||
{{## def._errorSchemas = { |
|||
'false schema': "false", |
|||
$ref: "{{=it.util.toQuotedString($schema)}}", |
|||
additionalItems: "false", |
|||
additionalProperties: "false", |
|||
anyOf: "validate.schema{{=$schemaPath}}", |
|||
const: "validate.schema{{=$schemaPath}}", |
|||
contains: "validate.schema{{=$schemaPath}}", |
|||
dependencies: "validate.schema{{=$schemaPath}}", |
|||
'enum': "validate.schema{{=$schemaPath}}", |
|||
format: "{{#def.schemaRefOrQS}}", |
|||
'if': "validate.schema{{=$schemaPath}}", |
|||
_limit: "{{#def.schemaRefOrVal}}", |
|||
_exclusiveLimit: "validate.schema{{=$schemaPath}}", |
|||
_limitItems: "{{#def.schemaRefOrVal}}", |
|||
_limitLength: "{{#def.schemaRefOrVal}}", |
|||
_limitProperties:"{{#def.schemaRefOrVal}}", |
|||
multipleOf: "{{#def.schemaRefOrVal}}", |
|||
not: "validate.schema{{=$schemaPath}}", |
|||
oneOf: "validate.schema{{=$schemaPath}}", |
|||
pattern: "{{#def.schemaRefOrQS}}", |
|||
propertyNames: "validate.schema{{=$schemaPath}}", |
|||
required: "validate.schema{{=$schemaPath}}", |
|||
type: "validate.schema{{=$schemaPath}}", |
|||
uniqueItems: "{{#def.schemaRefOrVal}}", |
|||
custom: "validate.schema{{=$schemaPath}}", |
|||
patternRequired: "validate.schema{{=$schemaPath}}", |
|||
switch: "validate.schema{{=$schemaPath}}", |
|||
_formatLimit: "{{#def.schemaRefOrQS}}", |
|||
_formatExclusiveLimit: "validate.schema{{=$schemaPath}}" |
|||
} #}} |
|||
|
|||
|
|||
{{## def.schemaValueQS: {{?$isData}}{{=$schemaValue}}{{??}}{{=it.util.toQuotedString($schema)}}{{?}} #}} |
|||
|
|||
{{## def._errorParams = { |
|||
'false schema': "{}", |
|||
$ref: "{ ref: '{{=it.util.escapeQuotes($schema)}}' }", |
|||
additionalItems: "{ limit: {{=$schema.length}} }", |
|||
additionalProperties: "{ additionalProperty: '{{=$additionalProperty}}' }", |
|||
anyOf: "{}", |
|||
const: "{ allowedValue: schema{{=$lvl}} }", |
|||
contains: "{}", |
|||
dependencies: "{ property: '{{= it.util.escapeQuotes($property) }}', missingProperty: '{{=$missingProperty}}', depsCount: {{=$deps.length}}, deps: '{{= it.util.escapeQuotes($deps.length==1 ? $deps[0] : $deps.join(\", \")) }}' }", |
|||
'enum': "{ allowedValues: schema{{=$lvl}} }", |
|||
format: "{ format: {{#def.schemaValueQS}} }", |
|||
'if': "{ failingKeyword: {{=$ifClause}} }", |
|||
_limit: "{ comparison: {{=$opExpr}}, limit: {{=$schemaValue}}, exclusive: {{=$exclusive}} }", |
|||
_exclusiveLimit: "{}", |
|||
_limitItems: "{ limit: {{=$schemaValue}} }", |
|||
_limitLength: "{ limit: {{=$schemaValue}} }", |
|||
_limitProperties:"{ limit: {{=$schemaValue}} }", |
|||
multipleOf: "{ multipleOf: {{=$schemaValue}} }", |
|||
not: "{}", |
|||
oneOf: "{ passingSchemas: {{=$passingSchemas}} }", |
|||
pattern: "{ pattern: {{#def.schemaValueQS}} }", |
|||
propertyNames: "{ propertyName: '{{=$invalidName}}' }", |
|||
required: "{ missingProperty: '{{=$missingProperty}}' }", |
|||
type: "{ type: '{{? $typeIsArray }}{{= $typeSchema.join(\",\") }}{{??}}{{=$typeSchema}}{{?}}' }", |
|||
uniqueItems: "{ i: i, j: j }", |
|||
custom: "{ keyword: '{{=$rule.keyword}}' }", |
|||
patternRequired: "{ missingPattern: '{{=$missingPattern}}' }", |
|||
switch: "{ caseIndex: {{=$caseIndex}} }", |
|||
_formatLimit: "{ comparison: {{=$opExpr}}, limit: {{#def.schemaValueQS}}, exclusive: {{=$exclusive}} }", |
|||
_formatExclusiveLimit: "{}" |
|||
} #}} |
|||
@ -1,106 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
|
|||
{{## def.skipFormat: |
|||
{{? $breakOnError }} if (true) { {{?}} |
|||
{{ return out; }} |
|||
#}} |
|||
|
|||
{{? it.opts.format === false }}{{# def.skipFormat }}{{?}} |
|||
|
|||
|
|||
{{# def.$data }} |
|||
|
|||
|
|||
{{## def.$dataCheckFormat: |
|||
{{# def.$dataNotType:'string' }} |
|||
({{? $unknownFormats != 'ignore' }} |
|||
({{=$schemaValue}} && !{{=$format}} |
|||
{{? $allowUnknown }} |
|||
&& self._opts.unknownFormats.indexOf({{=$schemaValue}}) == -1 |
|||
{{?}}) || |
|||
{{?}} |
|||
({{=$format}} && {{=$formatType}} == '{{=$ruleType}}' |
|||
&& !(typeof {{=$format}} == 'function' |
|||
? {{? it.async}} |
|||
(async{{=$lvl}} ? await {{=$format}}({{=$data}}) : {{=$format}}({{=$data}})) |
|||
{{??}} |
|||
{{=$format}}({{=$data}}) |
|||
{{?}} |
|||
: {{=$format}}.test({{=$data}})))) |
|||
#}} |
|||
|
|||
{{## def.checkFormat: |
|||
{{ |
|||
var $formatRef = 'formats' + it.util.getProperty($schema); |
|||
if ($isObject) $formatRef += '.validate'; |
|||
}} |
|||
{{? typeof $format == 'function' }} |
|||
{{=$formatRef}}({{=$data}}) |
|||
{{??}} |
|||
{{=$formatRef}}.test({{=$data}}) |
|||
{{?}} |
|||
#}} |
|||
|
|||
|
|||
{{ |
|||
var $unknownFormats = it.opts.unknownFormats |
|||
, $allowUnknown = Array.isArray($unknownFormats); |
|||
}} |
|||
|
|||
{{? $isData }} |
|||
{{ |
|||
var $format = 'format' + $lvl |
|||
, $isObject = 'isObject' + $lvl |
|||
, $formatType = 'formatType' + $lvl; |
|||
}} |
|||
var {{=$format}} = formats[{{=$schemaValue}}]; |
|||
var {{=$isObject}} = typeof {{=$format}} == 'object' |
|||
&& !({{=$format}} instanceof RegExp) |
|||
&& {{=$format}}.validate; |
|||
var {{=$formatType}} = {{=$isObject}} && {{=$format}}.type || 'string'; |
|||
if ({{=$isObject}}) { |
|||
{{? it.async}} |
|||
var async{{=$lvl}} = {{=$format}}.async; |
|||
{{?}} |
|||
{{=$format}} = {{=$format}}.validate; |
|||
} |
|||
if ({{# def.$dataCheckFormat }}) { |
|||
{{??}} |
|||
{{ var $format = it.formats[$schema]; }} |
|||
{{? !$format }} |
|||
{{? $unknownFormats == 'ignore' }} |
|||
{{ it.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"'); }} |
|||
{{# def.skipFormat }} |
|||
{{?? $allowUnknown && $unknownFormats.indexOf($schema) >= 0 }} |
|||
{{# def.skipFormat }} |
|||
{{??}} |
|||
{{ throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it.errSchemaPath + '"'); }} |
|||
{{?}} |
|||
{{?}} |
|||
{{ |
|||
var $isObject = typeof $format == 'object' |
|||
&& !($format instanceof RegExp) |
|||
&& $format.validate; |
|||
var $formatType = $isObject && $format.type || 'string'; |
|||
if ($isObject) { |
|||
var $async = $format.async === true; |
|||
$format = $format.validate; |
|||
} |
|||
}} |
|||
{{? $formatType != $ruleType }} |
|||
{{# def.skipFormat }} |
|||
{{?}} |
|||
{{? $async }} |
|||
{{ |
|||
if (!it.async) throw new Error('async format in sync schema'); |
|||
var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate'; |
|||
}} |
|||
if (!(await {{=$formatRef}}({{=$data}}))) { |
|||
{{??}} |
|||
if (!{{# def.checkFormat }}) { |
|||
{{?}} |
|||
{{?}} |
|||
{{# def.error:'format' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,73 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
|
|||
{{## def.validateIfClause:_clause: |
|||
{{ |
|||
$it.schema = it.schema['_clause']; |
|||
$it.schemaPath = it.schemaPath + '._clause'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/_clause'; |
|||
}} |
|||
{{# def.insertSubschemaCode }} |
|||
{{=$valid}} = {{=$nextValid}}; |
|||
{{? $thenPresent && $elsePresent }} |
|||
{{ $ifClause = 'ifClause' + $lvl; }} |
|||
var {{=$ifClause}} = '_clause'; |
|||
{{??}} |
|||
{{ $ifClause = '\'_clause\''; }} |
|||
{{?}} |
|||
#}} |
|||
|
|||
{{ |
|||
var $thenSch = it.schema['then'] |
|||
, $elseSch = it.schema['else'] |
|||
, $thenPresent = $thenSch !== undefined && {{# def.nonEmptySchema:$thenSch }} |
|||
, $elsePresent = $elseSch !== undefined && {{# def.nonEmptySchema:$elseSch }} |
|||
, $currentBaseId = $it.baseId; |
|||
}} |
|||
|
|||
{{? $thenPresent || $elsePresent }} |
|||
{{ |
|||
var $ifClause; |
|||
$it.createErrors = false; |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
}} |
|||
var {{=$errs}} = errors; |
|||
var {{=$valid}} = true; |
|||
|
|||
{{# def.setCompositeRule }} |
|||
{{# def.insertSubschemaCode }} |
|||
{{ $it.createErrors = true; }} |
|||
{{# def.resetErrors }} |
|||
{{# def.resetCompositeRule }} |
|||
|
|||
{{? $thenPresent }} |
|||
if ({{=$nextValid}}) { |
|||
{{# def.validateIfClause:then }} |
|||
} |
|||
{{? $elsePresent }} |
|||
else { |
|||
{{?}} |
|||
{{??}} |
|||
if (!{{=$nextValid}}) { |
|||
{{?}} |
|||
|
|||
{{? $elsePresent }} |
|||
{{# def.validateIfClause:else }} |
|||
} |
|||
{{?}} |
|||
|
|||
if (!{{=$valid}}) { |
|||
{{# def.extraError:'if' }} |
|||
} |
|||
{{? $breakOnError }} else { {{?}} |
|||
{{??}} |
|||
{{? $breakOnError }} |
|||
if (true) { |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
@ -1,98 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
|
|||
{{## def.validateItems:startFrom: |
|||
for (var {{=$idx}} = {{=startFrom}}; {{=$idx}} < {{=$data}}.length; {{=$idx}}++) { |
|||
{{ |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|||
var $passData = $data + '[' + $idx + ']'; |
|||
$it.dataPathArr[$dataNxt] = $idx; |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
|
|||
{{? $breakOnError }} |
|||
if (!{{=$nextValid}}) break; |
|||
{{?}} |
|||
} |
|||
#}} |
|||
|
|||
{{ |
|||
var $idx = 'i' + $lvl |
|||
, $dataNxt = $it.dataLevel = it.dataLevel + 1 |
|||
, $nextData = 'data' + $dataNxt |
|||
, $currentBaseId = it.baseId; |
|||
}} |
|||
|
|||
var {{=$errs}} = errors; |
|||
var {{=$valid}}; |
|||
|
|||
{{? Array.isArray($schema) }} |
|||
{{ /* 'items' is an array of schemas */}} |
|||
{{ var $additionalItems = it.schema.additionalItems; }} |
|||
{{? $additionalItems === false }} |
|||
{{=$valid}} = {{=$data}}.length <= {{= $schema.length }}; |
|||
{{ |
|||
var $currErrSchemaPath = $errSchemaPath; |
|||
$errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|||
}} |
|||
{{# def.checkError:'additionalItems' }} |
|||
{{ $errSchemaPath = $currErrSchemaPath; }} |
|||
{{# def.elseIfValid}} |
|||
{{?}} |
|||
|
|||
{{~ $schema:$sch:$i }} |
|||
{{? {{# def.nonEmptySchema:$sch }} }} |
|||
{{=$nextValid}} = true; |
|||
|
|||
if ({{=$data}}.length > {{=$i}}) { |
|||
{{ |
|||
var $passData = $data + '[' + $i + ']'; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true); |
|||
$it.dataPathArr[$dataNxt] = $i; |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} |
|||
{{~}} |
|||
|
|||
{{? typeof $additionalItems == 'object' && {{# def.nonEmptySchema:$additionalItems }} }} |
|||
{{ |
|||
$it.schema = $additionalItems; |
|||
$it.schemaPath = it.schemaPath + '.additionalItems'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|||
}} |
|||
{{=$nextValid}} = true; |
|||
|
|||
if ({{=$data}}.length > {{= $schema.length }}) { |
|||
{{# def.validateItems: $schema.length }} |
|||
} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} |
|||
|
|||
{{?? {{# def.nonEmptySchema:$schema }} }} |
|||
{{ /* 'items' is a single schema */}} |
|||
{{ |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
}} |
|||
{{# def.validateItems: 0 }} |
|||
{{?}} |
|||
|
|||
{{? $breakOnError }} |
|||
{{= $closingBraces }} |
|||
if ({{=$errs}} == errors) { |
|||
{{?}} |
|||
@ -1,39 +0,0 @@ |
|||
{{## def.checkMissingProperty:_properties: |
|||
{{~ _properties:$propertyKey:$i }} |
|||
{{?$i}} || {{?}} |
|||
{{ |
|||
var $prop = it.util.getProperty($propertyKey) |
|||
, $useData = $data + $prop; |
|||
}} |
|||
( ({{# def.noPropertyInData }}) && (missing{{=$lvl}} = {{= it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) }}) ) |
|||
{{~}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.errorMissingProperty:_error: |
|||
{{ |
|||
var $propertyPath = 'missing' + $lvl |
|||
, $missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.opts.jsonPointers |
|||
? it.util.getPathExpr($currentErrorPath, $propertyPath, true) |
|||
: $currentErrorPath + ' + ' + $propertyPath; |
|||
} |
|||
}} |
|||
{{# def.error:_error }} |
|||
#}} |
|||
|
|||
|
|||
{{## def.allErrorsMissingProperty:_error: |
|||
{{ |
|||
var $prop = it.util.getProperty($propertyKey) |
|||
, $missingProperty = it.util.escapeQuotes($propertyKey) |
|||
, $useData = $data + $prop; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|||
} |
|||
}} |
|||
if ({{# def.noPropertyInData }}) { |
|||
{{# def.addError:_error }} |
|||
} |
|||
#}} |
|||
@ -1,22 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{# def.numberKeyword }} |
|||
|
|||
var division{{=$lvl}}; |
|||
if ({{?$isData}} |
|||
{{=$schemaValue}} !== undefined && ( |
|||
typeof {{=$schemaValue}} != 'number' || |
|||
{{?}} |
|||
(division{{=$lvl}} = {{=$data}} / {{=$schemaValue}}, |
|||
{{? it.opts.multipleOfPrecision }} |
|||
Math.abs(Math.round(division{{=$lvl}}) - division{{=$lvl}}) > 1e-{{=it.opts.multipleOfPrecision}} |
|||
{{??}} |
|||
division{{=$lvl}} !== parseInt(division{{=$lvl}}) |
|||
{{?}} |
|||
) |
|||
{{?$isData}} ) {{?}} ) { |
|||
{{# def.error:'multipleOf' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,43 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
{{? {{# def.nonEmptySchema:$schema }} }} |
|||
{{ |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
}} |
|||
|
|||
var {{=$errs}} = errors; |
|||
|
|||
{{# def.setCompositeRule }} |
|||
|
|||
{{ |
|||
$it.createErrors = false; |
|||
var $allErrorsOption; |
|||
if ($it.opts.allErrors) { |
|||
$allErrorsOption = $it.opts.allErrors; |
|||
$it.opts.allErrors = false; |
|||
} |
|||
}} |
|||
{{= it.validate($it) }} |
|||
{{ |
|||
$it.createErrors = true; |
|||
if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption; |
|||
}} |
|||
|
|||
{{# def.resetCompositeRule }} |
|||
|
|||
if ({{=$nextValid}}) { |
|||
{{# def.error:'not' }} |
|||
} else { |
|||
{{# def.resetErrors }} |
|||
{{? it.opts.allErrors }} } {{?}} |
|||
{{??}} |
|||
{{# def.addError:'not' }} |
|||
{{? $breakOnError}} |
|||
if (false) { |
|||
{{?}} |
|||
{{?}} |
|||
@ -1,54 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
{{ |
|||
var $currentBaseId = $it.baseId |
|||
, $prevValid = 'prevValid' + $lvl |
|||
, $passingSchemas = 'passingSchemas' + $lvl; |
|||
}} |
|||
|
|||
var {{=$errs}} = errors |
|||
, {{=$prevValid}} = false |
|||
, {{=$valid}} = false |
|||
, {{=$passingSchemas}} = null; |
|||
|
|||
{{# def.setCompositeRule }} |
|||
|
|||
{{~ $schema:$sch:$i }} |
|||
{{? {{# def.nonEmptySchema:$sch }} }} |
|||
{{ |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
}} |
|||
|
|||
{{# def.insertSubschemaCode }} |
|||
{{??}} |
|||
var {{=$nextValid}} = true; |
|||
{{?}} |
|||
|
|||
{{? $i }} |
|||
if ({{=$nextValid}} && {{=$prevValid}}) { |
|||
{{=$valid}} = false; |
|||
{{=$passingSchemas}} = [{{=$passingSchemas}}, {{=$i}}]; |
|||
} else { |
|||
{{ $closingBraces += '}'; }} |
|||
{{?}} |
|||
|
|||
if ({{=$nextValid}}) { |
|||
{{=$valid}} = {{=$prevValid}} = true; |
|||
{{=$passingSchemas}} = {{=$i}}; |
|||
} |
|||
{{~}} |
|||
|
|||
{{# def.resetCompositeRule }} |
|||
|
|||
{{= $closingBraces }} |
|||
|
|||
if (!{{=$valid}}) { |
|||
{{# def.extraError:'oneOf' }} |
|||
} else { |
|||
{{# def.resetErrors }} |
|||
{{? it.opts.allErrors }} } {{?}} |
|||
@ -1,14 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{ |
|||
var $regexp = $isData |
|||
? '(new RegExp(' + $schemaValue + '))' |
|||
: it.usePattern($schema); |
|||
}} |
|||
|
|||
if ({{# def.$dataNotType:'string' }} !{{=$regexp}}.test({{=$data}}) ) { |
|||
{{# def.error:'pattern' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
@ -1,245 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
|
|||
{{## def.validateAdditional: |
|||
{{ /* additionalProperties is schema */ |
|||
$it.schema = $aProperties; |
|||
$it.schemaPath = it.schemaPath + '.additionalProperties'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|||
$it.errorPath = it.opts._errorDataPathProperty |
|||
? it.errorPath |
|||
: it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
var $passData = $data + '[' + $key + ']'; |
|||
$it.dataPathArr[$dataNxt] = $key; |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
#}} |
|||
|
|||
|
|||
{{ |
|||
var $key = 'key' + $lvl |
|||
, $idx = 'idx' + $lvl |
|||
, $dataNxt = $it.dataLevel = it.dataLevel + 1 |
|||
, $nextData = 'data' + $dataNxt |
|||
, $dataProperties = 'dataProperties' + $lvl; |
|||
|
|||
var $schemaKeys = Object.keys($schema || {}).filter(notProto) |
|||
, $pProperties = it.schema.patternProperties || {} |
|||
, $pPropertyKeys = Object.keys($pProperties).filter(notProto) |
|||
, $aProperties = it.schema.additionalProperties |
|||
, $someProperties = $schemaKeys.length || $pPropertyKeys.length |
|||
, $noAdditional = $aProperties === false |
|||
, $additionalIsSchema = typeof $aProperties == 'object' |
|||
&& Object.keys($aProperties).length |
|||
, $removeAdditional = it.opts.removeAdditional |
|||
, $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional |
|||
, $ownProperties = it.opts.ownProperties |
|||
, $currentBaseId = it.baseId; |
|||
|
|||
var $required = it.schema.required; |
|||
if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) { |
|||
var $requiredHash = it.util.toHash($required); |
|||
} |
|||
|
|||
function notProto(p) { return p !== '__proto__'; } |
|||
}} |
|||
|
|||
|
|||
var {{=$errs}} = errors; |
|||
var {{=$nextValid}} = true; |
|||
{{? $ownProperties }} |
|||
var {{=$dataProperties}} = undefined; |
|||
{{?}} |
|||
|
|||
{{? $checkAdditional }} |
|||
{{# def.iterateProperties }} |
|||
{{? $someProperties }} |
|||
var isAdditional{{=$lvl}} = !(false |
|||
{{? $schemaKeys.length }} |
|||
{{? $schemaKeys.length > 8 }} |
|||
|| validate.schema{{=$schemaPath}}.hasOwnProperty({{=$key}}) |
|||
{{??}} |
|||
{{~ $schemaKeys:$propertyKey }} |
|||
|| {{=$key}} == {{= it.util.toQuotedString($propertyKey) }} |
|||
{{~}} |
|||
{{?}} |
|||
{{?}} |
|||
{{? $pPropertyKeys.length }} |
|||
{{~ $pPropertyKeys:$pProperty:$i }} |
|||
|| {{= it.usePattern($pProperty) }}.test({{=$key}}) |
|||
{{~}} |
|||
{{?}} |
|||
); |
|||
|
|||
if (isAdditional{{=$lvl}}) { |
|||
{{?}} |
|||
{{? $removeAdditional == 'all' }} |
|||
delete {{=$data}}[{{=$key}}]; |
|||
{{??}} |
|||
{{ |
|||
var $currentErrorPath = it.errorPath; |
|||
var $additionalProperty = '\' + ' + $key + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
} |
|||
}} |
|||
{{? $noAdditional }} |
|||
{{? $removeAdditional }} |
|||
delete {{=$data}}[{{=$key}}]; |
|||
{{??}} |
|||
{{=$nextValid}} = false; |
|||
{{ |
|||
var $currErrSchemaPath = $errSchemaPath; |
|||
$errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|||
}} |
|||
{{# def.error:'additionalProperties' }} |
|||
{{ $errSchemaPath = $currErrSchemaPath; }} |
|||
{{? $breakOnError }} break; {{?}} |
|||
{{?}} |
|||
{{?? $additionalIsSchema }} |
|||
{{? $removeAdditional == 'failing' }} |
|||
var {{=$errs}} = errors; |
|||
{{# def.setCompositeRule }} |
|||
|
|||
{{# def.validateAdditional }} |
|||
|
|||
if (!{{=$nextValid}}) { |
|||
errors = {{=$errs}}; |
|||
if (validate.errors !== null) { |
|||
if (errors) validate.errors.length = errors; |
|||
else validate.errors = null; |
|||
} |
|||
delete {{=$data}}[{{=$key}}]; |
|||
} |
|||
|
|||
{{# def.resetCompositeRule }} |
|||
{{??}} |
|||
{{# def.validateAdditional }} |
|||
{{? $breakOnError }} if (!{{=$nextValid}}) break; {{?}} |
|||
{{?}} |
|||
{{?}} |
|||
{{ it.errorPath = $currentErrorPath; }} |
|||
{{?}} |
|||
{{? $someProperties }} |
|||
} |
|||
{{?}} |
|||
} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} |
|||
|
|||
{{ var $useDefaults = it.opts.useDefaults && !it.compositeRule; }} |
|||
|
|||
{{? $schemaKeys.length }} |
|||
{{~ $schemaKeys:$propertyKey }} |
|||
{{ var $sch = $schema[$propertyKey]; }} |
|||
|
|||
{{? {{# def.nonEmptySchema:$sch}} }} |
|||
{{ |
|||
var $prop = it.util.getProperty($propertyKey) |
|||
, $passData = $data + $prop |
|||
, $hasDefault = $useDefaults && $sch.default !== undefined; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + $prop; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey); |
|||
$it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers); |
|||
$it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey); |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
|
|||
{{? {{# def.willOptimize }} }} |
|||
{{ |
|||
$code = {{# def._optimizeValidate }}; |
|||
var $useData = $passData; |
|||
}} |
|||
{{??}} |
|||
{{ var $useData = $nextData; }} |
|||
var {{=$nextData}} = {{=$passData}}; |
|||
{{?}} |
|||
|
|||
{{? $hasDefault }} |
|||
{{= $code }} |
|||
{{??}} |
|||
{{? $requiredHash && $requiredHash[$propertyKey] }} |
|||
if ({{# def.noPropertyInData }}) { |
|||
{{=$nextValid}} = false; |
|||
{{ |
|||
var $currentErrorPath = it.errorPath |
|||
, $currErrSchemaPath = $errSchemaPath |
|||
, $missingProperty = it.util.escapeQuotes($propertyKey); |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|||
} |
|||
$errSchemaPath = it.errSchemaPath + '/required'; |
|||
}} |
|||
{{# def.error:'required' }} |
|||
{{ $errSchemaPath = $currErrSchemaPath; }} |
|||
{{ it.errorPath = $currentErrorPath; }} |
|||
} else { |
|||
{{??}} |
|||
{{? $breakOnError }} |
|||
if ({{# def.noPropertyInData }}) { |
|||
{{=$nextValid}} = true; |
|||
} else { |
|||
{{??}} |
|||
if ({{=$useData}} !== undefined |
|||
{{? $ownProperties }} |
|||
&& {{# def.isOwnProperty }} |
|||
{{?}} |
|||
) { |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{= $code }} |
|||
} |
|||
{{?}} {{ /* $hasDefault */ }} |
|||
{{?}} {{ /* def.nonEmptySchema */ }} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{~}} |
|||
{{?}} |
|||
|
|||
{{? $pPropertyKeys.length }} |
|||
{{~ $pPropertyKeys:$pProperty }} |
|||
{{ var $sch = $pProperties[$pProperty]; }} |
|||
|
|||
{{? {{# def.nonEmptySchema:$sch}} }} |
|||
{{ |
|||
$it.schema = $sch; |
|||
$it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty); |
|||
$it.errSchemaPath = it.errSchemaPath + '/patternProperties/' |
|||
+ it.util.escapeFragment($pProperty); |
|||
}} |
|||
|
|||
{{# def.iterateProperties }} |
|||
if ({{= it.usePattern($pProperty) }}.test({{=$key}})) { |
|||
{{ |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
var $passData = $data + '[' + $key + ']'; |
|||
$it.dataPathArr[$dataNxt] = $key; |
|||
}} |
|||
|
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
|
|||
{{? $breakOnError }} if (!{{=$nextValid}}) break; {{?}} |
|||
} |
|||
{{? $breakOnError }} else {{=$nextValid}} = true; {{?}} |
|||
} |
|||
|
|||
{{# def.ifResultValid }} |
|||
{{?}} {{ /* def.nonEmptySchema */ }} |
|||
{{~}} |
|||
{{?}} |
|||
|
|||
|
|||
{{? $breakOnError }} |
|||
{{= $closingBraces }} |
|||
if ({{=$errs}} == errors) { |
|||
{{?}} |
|||
@ -1,52 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.setupNextLevel }} |
|||
|
|||
var {{=$errs}} = errors; |
|||
|
|||
{{? {{# def.nonEmptySchema:$schema }} }} |
|||
{{ |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
}} |
|||
|
|||
{{ |
|||
var $key = 'key' + $lvl |
|||
, $idx = 'idx' + $lvl |
|||
, $i = 'i' + $lvl |
|||
, $invalidName = '\' + ' + $key + ' + \'' |
|||
, $dataNxt = $it.dataLevel = it.dataLevel + 1 |
|||
, $nextData = 'data' + $dataNxt |
|||
, $dataProperties = 'dataProperties' + $lvl |
|||
, $ownProperties = it.opts.ownProperties |
|||
, $currentBaseId = it.baseId; |
|||
}} |
|||
|
|||
{{? $ownProperties }} |
|||
var {{=$dataProperties}} = undefined; |
|||
{{?}} |
|||
{{# def.iterateProperties }} |
|||
var startErrs{{=$lvl}} = errors; |
|||
|
|||
{{ var $passData = $key; }} |
|||
{{# def.setCompositeRule }} |
|||
{{# def.generateSubschemaCode }} |
|||
{{# def.optimizeValidate }} |
|||
{{# def.resetCompositeRule }} |
|||
|
|||
if (!{{=$nextValid}}) { |
|||
for (var {{=$i}}=startErrs{{=$lvl}}; {{=$i}}<errors; {{=$i}}++) { |
|||
vErrors[{{=$i}}].propertyName = {{=$key}}; |
|||
} |
|||
{{# def.extraError:'propertyNames' }} |
|||
{{? $breakOnError }} break; {{?}} |
|||
} |
|||
} |
|||
{{?}} |
|||
|
|||
{{? $breakOnError }} |
|||
{{= $closingBraces }} |
|||
if ({{=$errs}} == errors) { |
|||
{{?}} |
|||
@ -1,85 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
|
|||
{{## def._validateRef:_v: |
|||
{{? it.opts.passContext }} |
|||
{{=_v}}.call(this, |
|||
{{??}} |
|||
{{=_v}}( |
|||
{{?}} |
|||
{{=$data}}, {{# def.dataPath }}{{# def.passParentData }}, rootData) |
|||
#}} |
|||
|
|||
{{ var $async, $refCode; }} |
|||
{{? $schema == '#' || $schema == '#/' }} |
|||
{{ |
|||
if (it.isRoot) { |
|||
$async = it.async; |
|||
$refCode = 'validate'; |
|||
} else { |
|||
$async = it.root.schema.$async === true; |
|||
$refCode = 'root.refVal[0]'; |
|||
} |
|||
}} |
|||
{{??}} |
|||
{{ var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot); }} |
|||
{{? $refVal === undefined }} |
|||
{{ var $message = it.MissingRefError.message(it.baseId, $schema); }} |
|||
{{? it.opts.missingRefs == 'fail' }} |
|||
{{ it.logger.error($message); }} |
|||
{{# def.error:'$ref' }} |
|||
{{? $breakOnError }} if (false) { {{?}} |
|||
{{?? it.opts.missingRefs == 'ignore' }} |
|||
{{ it.logger.warn($message); }} |
|||
{{? $breakOnError }} if (true) { {{?}} |
|||
{{??}} |
|||
{{ throw new it.MissingRefError(it.baseId, $schema, $message); }} |
|||
{{?}} |
|||
{{?? $refVal.inline }} |
|||
{{# def.setupNextLevel }} |
|||
{{ |
|||
$it.schema = $refVal.schema; |
|||
$it.schemaPath = ''; |
|||
$it.errSchemaPath = $schema; |
|||
}} |
|||
{{ var $code = it.validate($it).replace(/validate\.schema/g, $refVal.code); }} |
|||
{{= $code }} |
|||
{{? $breakOnError}} |
|||
if ({{=$nextValid}}) { |
|||
{{?}} |
|||
{{??}} |
|||
{{ |
|||
$async = $refVal.$async === true || (it.async && $refVal.$async !== false); |
|||
$refCode = $refVal.code; |
|||
}} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? $refCode }} |
|||
{{# def.beginDefOut}} |
|||
{{# def._validateRef:$refCode }} |
|||
{{# def.storeDefOut:__callValidate }} |
|||
|
|||
{{? $async }} |
|||
{{ if (!it.async) throw new Error('async schema referenced by sync schema'); }} |
|||
{{? $breakOnError }} var {{=$valid}}; {{?}} |
|||
try { |
|||
await {{=__callValidate}}; |
|||
{{? $breakOnError }} {{=$valid}} = true; {{?}} |
|||
} catch (e) { |
|||
if (!(e instanceof ValidationError)) throw e; |
|||
if (vErrors === null) vErrors = e.errors; |
|||
else vErrors = vErrors.concat(e.errors); |
|||
errors = vErrors.length; |
|||
{{? $breakOnError }} {{=$valid}} = false; {{?}} |
|||
} |
|||
{{? $breakOnError }} if ({{=$valid}}) { {{?}} |
|||
{{??}} |
|||
if (!{{=__callValidate}}) { |
|||
if (vErrors === null) vErrors = {{=$refCode}}.errors; |
|||
else vErrors = vErrors.concat({{=$refCode}}.errors); |
|||
errors = vErrors.length; |
|||
} {{? $breakOnError }} else { {{?}} |
|||
{{?}} |
|||
{{?}} |
|||
@ -1,108 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.missing }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
{{ var $vSchema = 'schema' + $lvl; }} |
|||
|
|||
{{## def.setupLoop: |
|||
{{? !$isData }} |
|||
var {{=$vSchema}} = validate.schema{{=$schemaPath}}; |
|||
{{?}} |
|||
|
|||
{{ |
|||
var $i = 'i' + $lvl |
|||
, $propertyPath = 'schema' + $lvl + '[' + $i + ']' |
|||
, $missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); |
|||
} |
|||
}} |
|||
#}} |
|||
|
|||
|
|||
{{## def.isRequiredOwnProperty: |
|||
Object.prototype.hasOwnProperty.call({{=$data}}, {{=$vSchema}}[{{=$i}}]) |
|||
#}} |
|||
|
|||
|
|||
{{? !$isData }} |
|||
{{? $schema.length < it.opts.loopRequired && |
|||
it.schema.properties && Object.keys(it.schema.properties).length }} |
|||
{{ var $required = []; }} |
|||
{{~ $schema:$property }} |
|||
{{ var $propertySch = it.schema.properties[$property]; }} |
|||
{{? !($propertySch && {{# def.nonEmptySchema:$propertySch}}) }} |
|||
{{ $required[$required.length] = $property; }} |
|||
{{?}} |
|||
{{~}} |
|||
{{??}} |
|||
{{ var $required = $schema; }} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
|
|||
{{? $isData || $required.length }} |
|||
{{ |
|||
var $currentErrorPath = it.errorPath |
|||
, $loopRequired = $isData || $required.length >= it.opts.loopRequired |
|||
, $ownProperties = it.opts.ownProperties; |
|||
}} |
|||
|
|||
{{? $breakOnError }} |
|||
var missing{{=$lvl}}; |
|||
{{? $loopRequired }} |
|||
{{# def.setupLoop }} |
|||
var {{=$valid}} = true; |
|||
|
|||
{{?$isData}}{{# def.check$dataIsArray }}{{?}} |
|||
|
|||
for (var {{=$i}} = 0; {{=$i}} < {{=$vSchema}}.length; {{=$i}}++) { |
|||
{{=$valid}} = {{=$data}}[{{=$vSchema}}[{{=$i}}]] !== undefined |
|||
{{? $ownProperties }} |
|||
&& {{# def.isRequiredOwnProperty }} |
|||
{{?}}; |
|||
if (!{{=$valid}}) break; |
|||
} |
|||
|
|||
{{? $isData }} } {{?}} |
|||
|
|||
{{# def.checkError:'required' }} |
|||
else { |
|||
{{??}} |
|||
if ({{# def.checkMissingProperty:$required }}) { |
|||
{{# def.errorMissingProperty:'required' }} |
|||
} else { |
|||
{{?}} |
|||
{{??}} |
|||
{{? $loopRequired }} |
|||
{{# def.setupLoop }} |
|||
{{? $isData }} |
|||
if ({{=$vSchema}} && !Array.isArray({{=$vSchema}})) { |
|||
{{# def.addError:'required' }} |
|||
} else if ({{=$vSchema}} !== undefined) { |
|||
{{?}} |
|||
|
|||
for (var {{=$i}} = 0; {{=$i}} < {{=$vSchema}}.length; {{=$i}}++) { |
|||
if ({{=$data}}[{{=$vSchema}}[{{=$i}}]] === undefined |
|||
{{? $ownProperties }} |
|||
|| !{{# def.isRequiredOwnProperty }} |
|||
{{?}}) { |
|||
{{# def.addError:'required' }} |
|||
} |
|||
} |
|||
|
|||
{{? $isData }} } {{?}} |
|||
{{??}} |
|||
{{~ $required:$propertyKey }} |
|||
{{# def.allErrorsMissingProperty:'required' }} |
|||
{{~}} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{ it.errorPath = $currentErrorPath; }} |
|||
|
|||
{{?? $breakOnError }} |
|||
if (true) { |
|||
{{?}} |
|||
@ -1,62 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.setupKeyword }} |
|||
{{# def.$data }} |
|||
|
|||
|
|||
{{? ($schema || $isData) && it.opts.uniqueItems !== false }} |
|||
{{? $isData }} |
|||
var {{=$valid}}; |
|||
if ({{=$schemaValue}} === false || {{=$schemaValue}} === undefined) |
|||
{{=$valid}} = true; |
|||
else if (typeof {{=$schemaValue}} != 'boolean') |
|||
{{=$valid}} = false; |
|||
else { |
|||
{{?}} |
|||
|
|||
var i = {{=$data}}.length |
|||
, {{=$valid}} = true |
|||
, j; |
|||
if (i > 1) { |
|||
{{ |
|||
var $itemType = it.schema.items && it.schema.items.type |
|||
, $typeIsArray = Array.isArray($itemType); |
|||
}} |
|||
{{? !$itemType || $itemType == 'object' || $itemType == 'array' || |
|||
($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0)) }} |
|||
outer: |
|||
for (;i--;) { |
|||
for (j = i; j--;) { |
|||
if (equal({{=$data}}[i], {{=$data}}[j])) { |
|||
{{=$valid}} = false; |
|||
break outer; |
|||
} |
|||
} |
|||
} |
|||
{{??}} |
|||
var itemIndices = {}, item; |
|||
for (;i--;) { |
|||
var item = {{=$data}}[i]; |
|||
{{ var $method = 'checkDataType' + ($typeIsArray ? 's' : ''); }} |
|||
if ({{= it.util[$method]($itemType, 'item', it.opts.strictNumbers, true) }}) continue; |
|||
{{? $typeIsArray}} |
|||
if (typeof item == 'string') item = '"' + item; |
|||
{{?}} |
|||
if (typeof itemIndices[item] == 'number') { |
|||
{{=$valid}} = false; |
|||
j = itemIndices[item]; |
|||
break; |
|||
} |
|||
itemIndices[item] = i; |
|||
} |
|||
{{?}} |
|||
} |
|||
|
|||
{{? $isData }} } {{?}} |
|||
|
|||
if (!{{=$valid}}) { |
|||
{{# def.error:'uniqueItems' }} |
|||
} {{? $breakOnError }} else { {{?}} |
|||
{{??}} |
|||
{{? $breakOnError }} if (true) { {{?}} |
|||
{{?}} |
|||
@ -1,276 +0,0 @@ |
|||
{{# def.definitions }} |
|||
{{# def.errors }} |
|||
{{# def.defaults }} |
|||
{{# def.coerce }} |
|||
|
|||
{{ /** |
|||
* schema compilation (render) time: |
|||
* it = { schema, RULES, _validate, opts } |
|||
* it.validate - this template function, |
|||
* it is used recursively to generate code for subschemas |
|||
* |
|||
* runtime: |
|||
* "validate" is a variable name to which this function will be assigned |
|||
* validateRef etc. are defined in the parent scope in index.js |
|||
*/ }} |
|||
|
|||
{{ |
|||
var $async = it.schema.$async === true |
|||
, $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref') |
|||
, $id = it.self._getId(it.schema); |
|||
}} |
|||
|
|||
{{ |
|||
if (it.opts.strictKeywords) { |
|||
var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords); |
|||
if ($unknownKwd) { |
|||
var $keywordsMsg = 'unknown keyword: ' + $unknownKwd; |
|||
if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg); |
|||
else throw new Error($keywordsMsg); |
|||
} |
|||
} |
|||
}} |
|||
|
|||
{{? it.isTop }} |
|||
var validate = {{?$async}}{{it.async = true;}}async {{?}}function(data, dataPath, parentData, parentDataProperty, rootData) { |
|||
'use strict'; |
|||
{{? $id && (it.opts.sourceCode || it.opts.processCode) }} |
|||
{{= '/\*# sourceURL=' + $id + ' */' }} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref) }} |
|||
{{ var $keyword = 'false schema'; }} |
|||
{{# def.setupKeyword }} |
|||
{{? it.schema === false}} |
|||
{{? it.isTop}} |
|||
{{ $breakOnError = true; }} |
|||
{{??}} |
|||
var {{=$valid}} = false; |
|||
{{?}} |
|||
{{# def.error:'false schema' }} |
|||
{{??}} |
|||
{{? it.isTop}} |
|||
{{? $async }} |
|||
return data; |
|||
{{??}} |
|||
validate.errors = null; |
|||
return true; |
|||
{{?}} |
|||
{{??}} |
|||
var {{=$valid}} = true; |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? it.isTop}} |
|||
}; |
|||
return validate; |
|||
{{?}} |
|||
|
|||
{{ return out; }} |
|||
{{?}} |
|||
|
|||
|
|||
{{? it.isTop }} |
|||
{{ |
|||
var $top = it.isTop |
|||
, $lvl = it.level = 0 |
|||
, $dataLvl = it.dataLevel = 0 |
|||
, $data = 'data'; |
|||
it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema)); |
|||
it.baseId = it.baseId || it.rootId; |
|||
delete it.isTop; |
|||
|
|||
it.dataPathArr = [""]; |
|||
|
|||
if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) { |
|||
var $defaultMsg = 'default is ignored in the schema root'; |
|||
if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
|||
else throw new Error($defaultMsg); |
|||
} |
|||
}} |
|||
|
|||
var vErrors = null; {{ /* don't edit, used in replace */ }} |
|||
var errors = 0; {{ /* don't edit, used in replace */ }} |
|||
if (rootData === undefined) rootData = data; {{ /* don't edit, used in replace */ }} |
|||
{{??}} |
|||
{{ |
|||
var $lvl = it.level |
|||
, $dataLvl = it.dataLevel |
|||
, $data = 'data' + ($dataLvl || ''); |
|||
|
|||
if ($id) it.baseId = it.resolve.url(it.baseId, $id); |
|||
|
|||
if ($async && !it.async) throw new Error('async schema in sync schema'); |
|||
}} |
|||
|
|||
var errs_{{=$lvl}} = errors; |
|||
{{?}} |
|||
|
|||
{{ |
|||
var $valid = 'valid' + $lvl |
|||
, $breakOnError = !it.opts.allErrors |
|||
, $closingBraces1 = '' |
|||
, $closingBraces2 = ''; |
|||
|
|||
var $errorKeyword; |
|||
var $typeSchema = it.schema.type |
|||
, $typeIsArray = Array.isArray($typeSchema); |
|||
|
|||
if ($typeSchema && it.opts.nullable && it.schema.nullable === true) { |
|||
if ($typeIsArray) { |
|||
if ($typeSchema.indexOf('null') == -1) |
|||
$typeSchema = $typeSchema.concat('null'); |
|||
} else if ($typeSchema != 'null') { |
|||
$typeSchema = [$typeSchema, 'null']; |
|||
$typeIsArray = true; |
|||
} |
|||
} |
|||
|
|||
if ($typeIsArray && $typeSchema.length == 1) { |
|||
$typeSchema = $typeSchema[0]; |
|||
$typeIsArray = false; |
|||
} |
|||
}} |
|||
|
|||
{{## def.checkType: |
|||
{{ |
|||
var $schemaPath = it.schemaPath + '.type' |
|||
, $errSchemaPath = it.errSchemaPath + '/type' |
|||
, $method = $typeIsArray ? 'checkDataTypes' : 'checkDataType'; |
|||
}} |
|||
|
|||
if ({{= it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true) }}) { |
|||
#}} |
|||
|
|||
{{? it.schema.$ref && $refKeywords }} |
|||
{{? it.opts.extendRefs == 'fail' }} |
|||
{{ throw new Error('$ref: validation keywords used in schema at path "' + it.errSchemaPath + '" (see option extendRefs)'); }} |
|||
{{?? it.opts.extendRefs !== true }} |
|||
{{ |
|||
$refKeywords = false; |
|||
it.logger.warn('$ref: keywords ignored in schema at path "' + it.errSchemaPath + '"'); |
|||
}} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? it.schema.$comment && it.opts.$comment }} |
|||
{{= it.RULES.all.$comment.code(it, '$comment') }} |
|||
{{?}} |
|||
|
|||
{{? $typeSchema }} |
|||
{{? it.opts.coerceTypes }} |
|||
{{ var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema); }} |
|||
{{?}} |
|||
|
|||
{{ var $rulesGroup = it.RULES.types[$typeSchema]; }} |
|||
{{? $coerceToTypes || $typeIsArray || $rulesGroup === true || |
|||
($rulesGroup && !$shouldUseGroup($rulesGroup)) }} |
|||
{{ |
|||
var $schemaPath = it.schemaPath + '.type' |
|||
, $errSchemaPath = it.errSchemaPath + '/type'; |
|||
}} |
|||
{{# def.checkType }} |
|||
{{? $coerceToTypes }} |
|||
{{# def.coerceType }} |
|||
{{??}} |
|||
{{# def.error:'type' }} |
|||
{{?}} |
|||
} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
|
|||
{{? it.schema.$ref && !$refKeywords }} |
|||
{{= it.RULES.all.$ref.code(it, '$ref') }} |
|||
{{? $breakOnError }} |
|||
} |
|||
if (errors === {{?$top}}0{{??}}errs_{{=$lvl}}{{?}}) { |
|||
{{ $closingBraces2 += '}'; }} |
|||
{{?}} |
|||
{{??}} |
|||
{{~ it.RULES:$rulesGroup }} |
|||
{{? $shouldUseGroup($rulesGroup) }} |
|||
{{? $rulesGroup.type }} |
|||
if ({{= it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers) }}) { |
|||
{{?}} |
|||
{{? it.opts.useDefaults }} |
|||
{{? $rulesGroup.type == 'object' && it.schema.properties }} |
|||
{{# def.defaultProperties }} |
|||
{{?? $rulesGroup.type == 'array' && Array.isArray(it.schema.items) }} |
|||
{{# def.defaultItems }} |
|||
{{?}} |
|||
{{?}} |
|||
{{~ $rulesGroup.rules:$rule }} |
|||
{{? $shouldUseRule($rule) }} |
|||
{{ var $code = $rule.code(it, $rule.keyword, $rulesGroup.type); }} |
|||
{{? $code }} |
|||
{{= $code }} |
|||
{{? $breakOnError }} |
|||
{{ $closingBraces1 += '}'; }} |
|||
{{?}} |
|||
{{?}} |
|||
{{?}} |
|||
{{~}} |
|||
{{? $breakOnError }} |
|||
{{= $closingBraces1 }} |
|||
{{ $closingBraces1 = ''; }} |
|||
{{?}} |
|||
{{? $rulesGroup.type }} |
|||
} |
|||
{{? $typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes }} |
|||
else { |
|||
{{ |
|||
var $schemaPath = it.schemaPath + '.type' |
|||
, $errSchemaPath = it.errSchemaPath + '/type'; |
|||
}} |
|||
{{# def.error:'type' }} |
|||
} |
|||
{{?}} |
|||
{{?}} |
|||
|
|||
{{? $breakOnError }} |
|||
if (errors === {{?$top}}0{{??}}errs_{{=$lvl}}{{?}}) { |
|||
{{ $closingBraces2 += '}'; }} |
|||
{{?}} |
|||
{{?}} |
|||
{{~}} |
|||
{{?}} |
|||
|
|||
{{? $breakOnError }} {{= $closingBraces2 }} {{?}} |
|||
|
|||
{{? $top }} |
|||
{{? $async }} |
|||
if (errors === 0) return data; {{ /* don't edit, used in replace */ }} |
|||
else throw new ValidationError(vErrors); {{ /* don't edit, used in replace */ }} |
|||
{{??}} |
|||
validate.errors = vErrors; {{ /* don't edit, used in replace */ }} |
|||
return errors === 0; {{ /* don't edit, used in replace */ }} |
|||
{{?}} |
|||
}; |
|||
|
|||
return validate; |
|||
{{??}} |
|||
var {{=$valid}} = errors === errs_{{=$lvl}}; |
|||
{{?}} |
|||
|
|||
{{ |
|||
function $shouldUseGroup($rulesGroup) { |
|||
var rules = $rulesGroup.rules; |
|||
for (var i=0; i < rules.length; i++) |
|||
if ($shouldUseRule(rules[i])) |
|||
return true; |
|||
} |
|||
|
|||
function $shouldUseRule($rule) { |
|||
return it.schema[$rule.keyword] !== undefined || |
|||
($rule.implements && $ruleImplementsSomeKeyword($rule)); |
|||
} |
|||
|
|||
function $ruleImplementsSomeKeyword($rule) { |
|||
var impl = $rule.implements; |
|||
for (var i=0; i < impl.length; i++) |
|||
if (it.schema[impl[i]] !== undefined) |
|||
return true; |
|||
} |
|||
}} |
|||
@ -1,3 +0,0 @@ |
|||
These files are compiled dot templates from dot folder. |
|||
|
|||
Do NOT edit them directly, edit the templates and run `npm run build` from main ajv folder. |
|||
@ -1,163 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate__limit(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $isMax = $keyword == 'maximum', |
|||
$exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum', |
|||
$schemaExcl = it.schema[$exclusiveKeyword], |
|||
$isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data, |
|||
$op = $isMax ? '<' : '>', |
|||
$notOp = $isMax ? '>' : '<', |
|||
$errorKeyword = undefined; |
|||
if (!($isData || typeof $schema == 'number' || $schema === undefined)) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
if (!($isDataExcl || $schemaExcl === undefined || typeof $schemaExcl == 'number' || typeof $schemaExcl == 'boolean')) { |
|||
throw new Error($exclusiveKeyword + ' must be number or boolean'); |
|||
} |
|||
if ($isDataExcl) { |
|||
var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr), |
|||
$exclusive = 'exclusive' + $lvl, |
|||
$exclType = 'exclType' + $lvl, |
|||
$exclIsNumber = 'exclIsNumber' + $lvl, |
|||
$opExpr = 'op' + $lvl, |
|||
$opStr = '\' + ' + $opExpr + ' + \''; |
|||
out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; '; |
|||
$schemaValueExcl = 'schemaExcl' + $lvl; |
|||
out += ' var ' + ($exclusive) + '; var ' + ($exclType) + ' = typeof ' + ($schemaValueExcl) + '; if (' + ($exclType) + ' != \'boolean\' && ' + ($exclType) + ' != \'undefined\' && ' + ($exclType) + ' != \'number\') { '; |
|||
var $errorKeyword = $exclusiveKeyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || '_exclusiveLimit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'' + ($exclusiveKeyword) + ' should be boolean\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } else if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
out += ' ' + ($exclType) + ' == \'number\' ? ( (' + ($exclusive) + ' = ' + ($schemaValue) + ' === undefined || ' + ($schemaValueExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ') ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValueExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) : ( (' + ($exclusive) + ' = ' + ($schemaValueExcl) + ' === true) ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValue) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { var op' + ($lvl) + ' = ' + ($exclusive) + ' ? \'' + ($op) + '\' : \'' + ($op) + '=\'; '; |
|||
if ($schema === undefined) { |
|||
$errorKeyword = $exclusiveKeyword; |
|||
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|||
$schemaValue = $schemaValueExcl; |
|||
$isData = $isDataExcl; |
|||
} |
|||
} else { |
|||
var $exclIsNumber = typeof $schemaExcl == 'number', |
|||
$opStr = $op; |
|||
if ($exclIsNumber && $isData) { |
|||
var $opExpr = '\'' + $opStr + '\''; |
|||
out += ' if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
out += ' ( ' + ($schemaValue) + ' === undefined || ' + ($schemaExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ' ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { '; |
|||
} else { |
|||
if ($exclIsNumber && $schema === undefined) { |
|||
$exclusive = true; |
|||
$errorKeyword = $exclusiveKeyword; |
|||
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|||
$schemaValue = $schemaExcl; |
|||
$notOp += '='; |
|||
} else { |
|||
if ($exclIsNumber) $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema); |
|||
if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) { |
|||
$exclusive = true; |
|||
$errorKeyword = $exclusiveKeyword; |
|||
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|||
$notOp += '='; |
|||
} else { |
|||
$exclusive = false; |
|||
$opStr += '='; |
|||
} |
|||
} |
|||
var $opExpr = '\'' + $opStr + '\''; |
|||
out += ' if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
out += ' ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' || ' + ($data) + ' !== ' + ($data) + ') { '; |
|||
} |
|||
} |
|||
$errorKeyword = $errorKeyword || $keyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || '_limit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit: ' + ($schemaValue) + ', exclusive: ' + ($exclusive) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be ' + ($opStr) + ' '; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue); |
|||
} else { |
|||
out += '' + ($schemaValue) + '\''; |
|||
} |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,80 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate__limitItems(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (!($isData || typeof $schema == 'number')) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
var $op = $keyword == 'maxItems' ? '>' : '<'; |
|||
out += 'if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|||
var $errorKeyword = $keyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || '_limitItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT have '; |
|||
if ($keyword == 'maxItems') { |
|||
out += 'more'; |
|||
} else { |
|||
out += 'fewer'; |
|||
} |
|||
out += ' than '; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue) + ' + \''; |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' items\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += '} '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,85 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate__limitLength(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (!($isData || typeof $schema == 'number')) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
var $op = $keyword == 'maxLength' ? '>' : '<'; |
|||
out += 'if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
if (it.opts.unicode === false) { |
|||
out += ' ' + ($data) + '.length '; |
|||
} else { |
|||
out += ' ucs2length(' + ($data) + ') '; |
|||
} |
|||
out += ' ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|||
var $errorKeyword = $keyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || '_limitLength') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT be '; |
|||
if ($keyword == 'maxLength') { |
|||
out += 'longer'; |
|||
} else { |
|||
out += 'shorter'; |
|||
} |
|||
out += ' than '; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue) + ' + \''; |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' characters\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += '} '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,80 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate__limitProperties(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (!($isData || typeof $schema == 'number')) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
var $op = $keyword == 'maxProperties' ? '>' : '<'; |
|||
out += 'if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|||
} |
|||
out += ' Object.keys(' + ($data) + ').length ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|||
var $errorKeyword = $keyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || '_limitProperties') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT have '; |
|||
if ($keyword == 'maxProperties') { |
|||
out += 'more'; |
|||
} else { |
|||
out += 'fewer'; |
|||
} |
|||
out += ' than '; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue) + ' + \''; |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' properties\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += '} '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_allOf(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $currentBaseId = $it.baseId, |
|||
$allSchemasEmpty = true; |
|||
var arr1 = $schema; |
|||
if (arr1) { |
|||
var $sch, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$sch = arr1[$i += 1]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
$allSchemasEmpty = false; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
if ($allSchemasEmpty) { |
|||
out += ' if (true) { '; |
|||
} else { |
|||
out += ' ' + ($closingBraces.slice(0, -1)) + ' '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,73 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_anyOf(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $noEmptySchema = $schema.every(function($sch) { |
|||
return (it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)); |
|||
}); |
|||
if ($noEmptySchema) { |
|||
var $currentBaseId = $it.baseId; |
|||
out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = false; '; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
var arr1 = $schema; |
|||
if (arr1) { |
|||
var $sch, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$sch = arr1[$i += 1]; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
out += ' ' + ($valid) + ' = ' + ($valid) + ' || ' + ($nextValid) + '; if (!' + ($valid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += ' ' + ($closingBraces) + ' if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('anyOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should match some schema in anyOf\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; return false; '; |
|||
} |
|||
} |
|||
out += ' } else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|||
if (it.opts.allErrors) { |
|||
out += ' } '; |
|||
} |
|||
} else { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,14 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_comment(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $schema = it.schema[$keyword]; |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $comment = it.util.toQuotedString($schema); |
|||
if (it.opts.$comment === true) { |
|||
out += ' console.log(' + ($comment) + ');'; |
|||
} else if (typeof it.opts.$comment == 'function') { |
|||
out += ' self._opts.$comment(' + ($comment) + ', ' + (it.util.toQuotedString($errSchemaPath)) + ', validate.root.schema);'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,56 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_const(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (!$isData) { |
|||
out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';'; |
|||
} |
|||
out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('const') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValue: schema' + ($lvl) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be equal to constant\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' }'; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,81 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_contains(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $idx = 'i' + $lvl, |
|||
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|||
$nextData = 'data' + $dataNxt, |
|||
$currentBaseId = it.baseId, |
|||
$nonEmptySchema = (it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all)); |
|||
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|||
if ($nonEmptySchema) { |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
out += ' var ' + ($nextValid) + ' = false; for (var ' + ($idx) + ' = 0; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|||
var $passData = $data + '[' + $idx + ']'; |
|||
$it.dataPathArr[$dataNxt] = $idx; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
out += ' if (' + ($nextValid) + ') break; } '; |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += ' ' + ($closingBraces) + ' if (!' + ($nextValid) + ') {'; |
|||
} else { |
|||
out += ' if (' + ($data) + '.length == 0) {'; |
|||
} |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('contains') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should contain a valid item\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } else { '; |
|||
if ($nonEmptySchema) { |
|||
out += ' errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|||
} |
|||
if (it.opts.allErrors) { |
|||
out += ' } '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,228 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_custom(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $rule = this, |
|||
$definition = 'definition' + $lvl, |
|||
$rDef = $rule.definition, |
|||
$closingBraces = ''; |
|||
var $compile, $inline, $macro, $ruleValidate, $validateCode; |
|||
if ($isData && $rDef.$data) { |
|||
$validateCode = 'keywordValidate' + $lvl; |
|||
var $validateSchema = $rDef.validateSchema; |
|||
out += ' var ' + ($definition) + ' = RULES.custom[\'' + ($keyword) + '\'].definition; var ' + ($validateCode) + ' = ' + ($definition) + '.validate;'; |
|||
} else { |
|||
$ruleValidate = it.useCustomRule($rule, $schema, it.schema, it); |
|||
if (!$ruleValidate) return; |
|||
$schemaValue = 'validate.schema' + $schemaPath; |
|||
$validateCode = $ruleValidate.code; |
|||
$compile = $rDef.compile; |
|||
$inline = $rDef.inline; |
|||
$macro = $rDef.macro; |
|||
} |
|||
var $ruleErrs = $validateCode + '.errors', |
|||
$i = 'i' + $lvl, |
|||
$ruleErr = 'ruleErr' + $lvl, |
|||
$asyncKeyword = $rDef.async; |
|||
if ($asyncKeyword && !it.async) throw new Error('async keyword in sync schema'); |
|||
if (!($inline || $macro)) { |
|||
out += '' + ($ruleErrs) + ' = null;'; |
|||
} |
|||
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|||
if ($isData && $rDef.$data) { |
|||
$closingBraces += '}'; |
|||
out += ' if (' + ($schemaValue) + ' === undefined) { ' + ($valid) + ' = true; } else { '; |
|||
if ($validateSchema) { |
|||
$closingBraces += '}'; |
|||
out += ' ' + ($valid) + ' = ' + ($definition) + '.validateSchema(' + ($schemaValue) + '); if (' + ($valid) + ') { '; |
|||
} |
|||
} |
|||
if ($inline) { |
|||
if ($rDef.statements) { |
|||
out += ' ' + ($ruleValidate.validate) + ' '; |
|||
} else { |
|||
out += ' ' + ($valid) + ' = ' + ($ruleValidate.validate) + '; '; |
|||
} |
|||
} else if ($macro) { |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
$it.schema = $ruleValidate.validate; |
|||
$it.schemaPath = ''; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
var $code = it.validate($it).replace(/validate\.schema/g, $validateCode); |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += ' ' + ($code); |
|||
} else { |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; |
|||
out += ' ' + ($validateCode) + '.call( '; |
|||
if (it.opts.passContext) { |
|||
out += 'this'; |
|||
} else { |
|||
out += 'self'; |
|||
} |
|||
if ($compile || $rDef.schema === false) { |
|||
out += ' , ' + ($data) + ' '; |
|||
} else { |
|||
out += ' , ' + ($schemaValue) + ' , ' + ($data) + ' , validate.schema' + (it.schemaPath) + ' '; |
|||
} |
|||
out += ' , (dataPath || \'\')'; |
|||
if (it.errorPath != '""') { |
|||
out += ' + ' + (it.errorPath); |
|||
} |
|||
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|||
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|||
out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ' , rootData ) '; |
|||
var def_callRuleValidate = out; |
|||
out = $$outStack.pop(); |
|||
if ($rDef.errors === false) { |
|||
out += ' ' + ($valid) + ' = '; |
|||
if ($asyncKeyword) { |
|||
out += 'await '; |
|||
} |
|||
out += '' + (def_callRuleValidate) + '; '; |
|||
} else { |
|||
if ($asyncKeyword) { |
|||
$ruleErrs = 'customErrors' + $lvl; |
|||
out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = await ' + (def_callRuleValidate) + '; } catch (e) { ' + ($valid) + ' = false; if (e instanceof ValidationError) ' + ($ruleErrs) + ' = e.errors; else throw e; } '; |
|||
} else { |
|||
out += ' ' + ($ruleErrs) + ' = null; ' + ($valid) + ' = ' + (def_callRuleValidate) + '; '; |
|||
} |
|||
} |
|||
} |
|||
if ($rDef.modifying) { |
|||
out += ' if (' + ($parentData) + ') ' + ($data) + ' = ' + ($parentData) + '[' + ($parentDataProperty) + '];'; |
|||
} |
|||
out += '' + ($closingBraces); |
|||
if ($rDef.valid) { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
} else { |
|||
out += ' if ( '; |
|||
if ($rDef.valid === undefined) { |
|||
out += ' !'; |
|||
if ($macro) { |
|||
out += '' + ($nextValid); |
|||
} else { |
|||
out += '' + ($valid); |
|||
} |
|||
} else { |
|||
out += ' ' + (!$rDef.valid) + ' '; |
|||
} |
|||
out += ') { '; |
|||
$errorKeyword = $rule.keyword; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'custom') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \'' + ($rule.keyword) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should pass "' + ($rule.keyword) + '" keyword validation\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
var def_customError = out; |
|||
out = $$outStack.pop(); |
|||
if ($inline) { |
|||
if ($rDef.errors) { |
|||
if ($rDef.errors != 'full') { |
|||
out += ' for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; } '; |
|||
if (it.opts.verbose) { |
|||
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|||
} |
|||
out += ' } '; |
|||
} |
|||
} else { |
|||
if ($rDef.errors === false) { |
|||
out += ' ' + (def_customError) + ' '; |
|||
} else { |
|||
out += ' if (' + ($errs) + ' == errors) { ' + (def_customError) + ' } else { for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; } '; |
|||
if (it.opts.verbose) { |
|||
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|||
} |
|||
out += ' } } '; |
|||
} |
|||
} |
|||
} else if ($macro) { |
|||
out += ' var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'custom') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \'' + ($rule.keyword) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should pass "' + ($rule.keyword) + '" keyword validation\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; return false; '; |
|||
} |
|||
} |
|||
} else { |
|||
if ($rDef.errors === false) { |
|||
out += ' ' + (def_customError) + ' '; |
|||
} else { |
|||
out += ' if (Array.isArray(' + ($ruleErrs) + ')) { if (vErrors === null) vErrors = ' + ($ruleErrs) + '; else vErrors = vErrors.concat(' + ($ruleErrs) + '); errors = vErrors.length; for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; '; |
|||
if (it.opts.verbose) { |
|||
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|||
} |
|||
out += ' } } else { ' + (def_customError) + ' } '; |
|||
} |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,168 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_dependencies(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $schemaDeps = {}, |
|||
$propertyDeps = {}, |
|||
$ownProperties = it.opts.ownProperties; |
|||
for ($property in $schema) { |
|||
if ($property == '__proto__') continue; |
|||
var $sch = $schema[$property]; |
|||
var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps; |
|||
$deps[$property] = $sch; |
|||
} |
|||
out += 'var ' + ($errs) + ' = errors;'; |
|||
var $currentErrorPath = it.errorPath; |
|||
out += 'var missing' + ($lvl) + ';'; |
|||
for (var $property in $propertyDeps) { |
|||
$deps = $propertyDeps[$property]; |
|||
if ($deps.length) { |
|||
out += ' if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined '; |
|||
if ($ownProperties) { |
|||
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($property)) + '\') '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' && ( '; |
|||
var arr1 = $deps; |
|||
if (arr1) { |
|||
var $propertyKey, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$propertyKey = arr1[$i += 1]; |
|||
if ($i) { |
|||
out += ' || '; |
|||
} |
|||
var $prop = it.util.getProperty($propertyKey), |
|||
$useData = $data + $prop; |
|||
out += ' ( ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) '; |
|||
} |
|||
} |
|||
out += ')) { '; |
|||
var $propertyPath = 'missing' + $lvl, |
|||
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath; |
|||
} |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('dependencies') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \'' + (it.util.escapeQuotes($property)) + '\', missingProperty: \'' + ($missingProperty) + '\', depsCount: ' + ($deps.length) + ', deps: \'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", "))) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should have '; |
|||
if ($deps.length == 1) { |
|||
out += 'property ' + (it.util.escapeQuotes($deps[0])); |
|||
} else { |
|||
out += 'properties ' + (it.util.escapeQuotes($deps.join(", "))); |
|||
} |
|||
out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
} else { |
|||
out += ' ) { '; |
|||
var arr2 = $deps; |
|||
if (arr2) { |
|||
var $propertyKey, i2 = -1, |
|||
l2 = arr2.length - 1; |
|||
while (i2 < l2) { |
|||
$propertyKey = arr2[i2 += 1]; |
|||
var $prop = it.util.getProperty($propertyKey), |
|||
$missingProperty = it.util.escapeQuotes($propertyKey), |
|||
$useData = $data + $prop; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|||
} |
|||
out += ' if ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('dependencies') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \'' + (it.util.escapeQuotes($property)) + '\', missingProperty: \'' + ($missingProperty) + '\', depsCount: ' + ($deps.length) + ', deps: \'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", "))) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should have '; |
|||
if ($deps.length == 1) { |
|||
out += 'property ' + (it.util.escapeQuotes($deps[0])); |
|||
} else { |
|||
out += 'properties ' + (it.util.escapeQuotes($deps.join(", "))); |
|||
} |
|||
out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } '; |
|||
} |
|||
} |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
$closingBraces += '}'; |
|||
out += ' else { '; |
|||
} |
|||
} |
|||
} |
|||
it.errorPath = $currentErrorPath; |
|||
var $currentBaseId = $it.baseId; |
|||
for (var $property in $schemaDeps) { |
|||
var $sch = $schemaDeps[$property]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
out += ' ' + ($nextValid) + ' = true; if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined '; |
|||
if ($ownProperties) { |
|||
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($property)) + '\') '; |
|||
} |
|||
out += ') { '; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + it.util.getProperty($property); |
|||
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property); |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,66 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_enum(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $i = 'i' + $lvl, |
|||
$vSchema = 'schema' + $lvl; |
|||
if (!$isData) { |
|||
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + ';'; |
|||
} |
|||
out += 'var ' + ($valid) + ';'; |
|||
if ($isData) { |
|||
out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {'; |
|||
} |
|||
out += '' + ($valid) + ' = false;for (var ' + ($i) + '=0; ' + ($i) + '<' + ($vSchema) + '.length; ' + ($i) + '++) if (equal(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + '])) { ' + ($valid) + ' = true; break; }'; |
|||
if ($isData) { |
|||
out += ' } '; |
|||
} |
|||
out += ' if (!' + ($valid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('enum') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValues: schema' + ($lvl) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be equal to one of the allowed values\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' }'; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,150 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_format(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
if (it.opts.format === false) { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
return out; |
|||
} |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $unknownFormats = it.opts.unknownFormats, |
|||
$allowUnknown = Array.isArray($unknownFormats); |
|||
if ($isData) { |
|||
var $format = 'format' + $lvl, |
|||
$isObject = 'isObject' + $lvl, |
|||
$formatType = 'formatType' + $lvl; |
|||
out += ' var ' + ($format) + ' = formats[' + ($schemaValue) + ']; var ' + ($isObject) + ' = typeof ' + ($format) + ' == \'object\' && !(' + ($format) + ' instanceof RegExp) && ' + ($format) + '.validate; var ' + ($formatType) + ' = ' + ($isObject) + ' && ' + ($format) + '.type || \'string\'; if (' + ($isObject) + ') { '; |
|||
if (it.async) { |
|||
out += ' var async' + ($lvl) + ' = ' + ($format) + '.async; '; |
|||
} |
|||
out += ' ' + ($format) + ' = ' + ($format) + '.validate; } if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'string\') || '; |
|||
} |
|||
out += ' ('; |
|||
if ($unknownFormats != 'ignore') { |
|||
out += ' (' + ($schemaValue) + ' && !' + ($format) + ' '; |
|||
if ($allowUnknown) { |
|||
out += ' && self._opts.unknownFormats.indexOf(' + ($schemaValue) + ') == -1 '; |
|||
} |
|||
out += ') || '; |
|||
} |
|||
out += ' (' + ($format) + ' && ' + ($formatType) + ' == \'' + ($ruleType) + '\' && !(typeof ' + ($format) + ' == \'function\' ? '; |
|||
if (it.async) { |
|||
out += ' (async' + ($lvl) + ' ? await ' + ($format) + '(' + ($data) + ') : ' + ($format) + '(' + ($data) + ')) '; |
|||
} else { |
|||
out += ' ' + ($format) + '(' + ($data) + ') '; |
|||
} |
|||
out += ' : ' + ($format) + '.test(' + ($data) + '))))) {'; |
|||
} else { |
|||
var $format = it.formats[$schema]; |
|||
if (!$format) { |
|||
if ($unknownFormats == 'ignore') { |
|||
it.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"'); |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
return out; |
|||
} else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
return out; |
|||
} else { |
|||
throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it.errSchemaPath + '"'); |
|||
} |
|||
} |
|||
var $isObject = typeof $format == 'object' && !($format instanceof RegExp) && $format.validate; |
|||
var $formatType = $isObject && $format.type || 'string'; |
|||
if ($isObject) { |
|||
var $async = $format.async === true; |
|||
$format = $format.validate; |
|||
} |
|||
if ($formatType != $ruleType) { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
return out; |
|||
} |
|||
if ($async) { |
|||
if (!it.async) throw new Error('async format in sync schema'); |
|||
var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate'; |
|||
out += ' if (!(await ' + ($formatRef) + '(' + ($data) + '))) { '; |
|||
} else { |
|||
out += ' if (! '; |
|||
var $formatRef = 'formats' + it.util.getProperty($schema); |
|||
if ($isObject) $formatRef += '.validate'; |
|||
if (typeof $format == 'function') { |
|||
out += ' ' + ($formatRef) + '(' + ($data) + ') '; |
|||
} else { |
|||
out += ' ' + ($formatRef) + '.test(' + ($data) + ') '; |
|||
} |
|||
out += ') { '; |
|||
} |
|||
} |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('format') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { format: '; |
|||
if ($isData) { |
|||
out += '' + ($schemaValue); |
|||
} else { |
|||
out += '' + (it.util.toQuotedString($schema)); |
|||
} |
|||
out += ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should match format "'; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue) + ' + \''; |
|||
} else { |
|||
out += '' + (it.util.escapeQuotes($schema)); |
|||
} |
|||
out += '"\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + (it.util.toQuotedString($schema)); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,103 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_if(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $thenSch = it.schema['then'], |
|||
$elseSch = it.schema['else'], |
|||
$thenPresent = $thenSch !== undefined && (it.opts.strictKeywords ? (typeof $thenSch == 'object' && Object.keys($thenSch).length > 0) || $thenSch === false : it.util.schemaHasRules($thenSch, it.RULES.all)), |
|||
$elsePresent = $elseSch !== undefined && (it.opts.strictKeywords ? (typeof $elseSch == 'object' && Object.keys($elseSch).length > 0) || $elseSch === false : it.util.schemaHasRules($elseSch, it.RULES.all)), |
|||
$currentBaseId = $it.baseId; |
|||
if ($thenPresent || $elsePresent) { |
|||
var $ifClause; |
|||
$it.createErrors = false; |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = true; '; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
$it.createErrors = true; |
|||
out += ' errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
if ($thenPresent) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$it.schema = it.schema['then']; |
|||
$it.schemaPath = it.schemaPath + '.then'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/then'; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
out += ' ' + ($valid) + ' = ' + ($nextValid) + '; '; |
|||
if ($thenPresent && $elsePresent) { |
|||
$ifClause = 'ifClause' + $lvl; |
|||
out += ' var ' + ($ifClause) + ' = \'then\'; '; |
|||
} else { |
|||
$ifClause = '\'then\''; |
|||
} |
|||
out += ' } '; |
|||
if ($elsePresent) { |
|||
out += ' else { '; |
|||
} |
|||
} else { |
|||
out += ' if (!' + ($nextValid) + ') { '; |
|||
} |
|||
if ($elsePresent) { |
|||
$it.schema = it.schema['else']; |
|||
$it.schemaPath = it.schemaPath + '.else'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/else'; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
out += ' ' + ($valid) + ' = ' + ($nextValid) + '; '; |
|||
if ($thenPresent && $elsePresent) { |
|||
$ifClause = 'ifClause' + $lvl; |
|||
out += ' var ' + ($ifClause) + ' = \'else\'; '; |
|||
} else { |
|||
$ifClause = '\'else\''; |
|||
} |
|||
out += ' } '; |
|||
} |
|||
out += ' if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('if') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { failingKeyword: ' + ($ifClause) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should match "\' + ' + ($ifClause) + ' + \'" schema\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; return false; '; |
|||
} |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
} else { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,33 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
//all requires must be explicit because browserify won't work with dynamic requires
|
|||
module.exports = { |
|||
'$ref': require('./ref'), |
|||
allOf: require('./allOf'), |
|||
anyOf: require('./anyOf'), |
|||
'$comment': require('./comment'), |
|||
const: require('./const'), |
|||
contains: require('./contains'), |
|||
dependencies: require('./dependencies'), |
|||
'enum': require('./enum'), |
|||
format: require('./format'), |
|||
'if': require('./if'), |
|||
items: require('./items'), |
|||
maximum: require('./_limit'), |
|||
minimum: require('./_limit'), |
|||
maxItems: require('./_limitItems'), |
|||
minItems: require('./_limitItems'), |
|||
maxLength: require('./_limitLength'), |
|||
minLength: require('./_limitLength'), |
|||
maxProperties: require('./_limitProperties'), |
|||
minProperties: require('./_limitProperties'), |
|||
multipleOf: require('./multipleOf'), |
|||
not: require('./not'), |
|||
oneOf: require('./oneOf'), |
|||
pattern: require('./pattern'), |
|||
properties: require('./properties'), |
|||
propertyNames: require('./propertyNames'), |
|||
required: require('./required'), |
|||
uniqueItems: require('./uniqueItems'), |
|||
validate: require('./validate') |
|||
}; |
|||
@ -1,140 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_items(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $idx = 'i' + $lvl, |
|||
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|||
$nextData = 'data' + $dataNxt, |
|||
$currentBaseId = it.baseId; |
|||
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|||
if (Array.isArray($schema)) { |
|||
var $additionalItems = it.schema.additionalItems; |
|||
if ($additionalItems === false) { |
|||
out += ' ' + ($valid) + ' = ' + ($data) + '.length <= ' + ($schema.length) + '; '; |
|||
var $currErrSchemaPath = $errSchemaPath; |
|||
$errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|||
out += ' if (!' + ($valid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('additionalItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schema.length) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT have more than ' + ($schema.length) + ' items\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } '; |
|||
$errSchemaPath = $currErrSchemaPath; |
|||
if ($breakOnError) { |
|||
$closingBraces += '}'; |
|||
out += ' else { '; |
|||
} |
|||
} |
|||
var arr1 = $schema; |
|||
if (arr1) { |
|||
var $sch, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$sch = arr1[$i += 1]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($i) + ') { '; |
|||
var $passData = $data + '[' + $i + ']'; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true); |
|||
$it.dataPathArr[$dataNxt] = $i; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if (typeof $additionalItems == 'object' && (it.opts.strictKeywords ? (typeof $additionalItems == 'object' && Object.keys($additionalItems).length > 0) || $additionalItems === false : it.util.schemaHasRules($additionalItems, it.RULES.all))) { |
|||
$it.schema = $additionalItems; |
|||
$it.schemaPath = it.schemaPath + '.additionalItems'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|||
out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($schema.length) + ') { for (var ' + ($idx) + ' = ' + ($schema.length) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|||
var $passData = $data + '[' + $idx + ']'; |
|||
$it.dataPathArr[$dataNxt] = $idx; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (!' + ($nextValid) + ') break; '; |
|||
} |
|||
out += ' } } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} else if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) { |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
out += ' for (var ' + ($idx) + ' = ' + (0) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|||
var $passData = $data + '[' + $idx + ']'; |
|||
$it.dataPathArr[$dataNxt] = $idx; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (!' + ($nextValid) + ') break; '; |
|||
} |
|||
out += ' }'; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,80 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_multipleOf(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (!($isData || typeof $schema == 'number')) { |
|||
throw new Error($keyword + ' must be number'); |
|||
} |
|||
out += 'var division' + ($lvl) + ';if ('; |
|||
if ($isData) { |
|||
out += ' ' + ($schemaValue) + ' !== undefined && ( typeof ' + ($schemaValue) + ' != \'number\' || '; |
|||
} |
|||
out += ' (division' + ($lvl) + ' = ' + ($data) + ' / ' + ($schemaValue) + ', '; |
|||
if (it.opts.multipleOfPrecision) { |
|||
out += ' Math.abs(Math.round(division' + ($lvl) + ') - division' + ($lvl) + ') > 1e-' + (it.opts.multipleOfPrecision) + ' '; |
|||
} else { |
|||
out += ' division' + ($lvl) + ' !== parseInt(division' + ($lvl) + ') '; |
|||
} |
|||
out += ' ) '; |
|||
if ($isData) { |
|||
out += ' ) '; |
|||
} |
|||
out += ' ) { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('multipleOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { multipleOf: ' + ($schemaValue) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be multiple of '; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue); |
|||
} else { |
|||
out += '' + ($schemaValue) + '\''; |
|||
} |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += '} '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,84 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_not(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) { |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
out += ' var ' + ($errs) + ' = errors; '; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
$it.createErrors = false; |
|||
var $allErrorsOption; |
|||
if ($it.opts.allErrors) { |
|||
$allErrorsOption = $it.opts.allErrors; |
|||
$it.opts.allErrors = false; |
|||
} |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.createErrors = true; |
|||
if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption; |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('not') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT be valid\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|||
if (it.opts.allErrors) { |
|||
out += ' } '; |
|||
} |
|||
} else { |
|||
out += ' var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('not') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT be valid\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if ($breakOnError) { |
|||
out += ' if (false) { '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,73 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_oneOf(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $currentBaseId = $it.baseId, |
|||
$prevValid = 'prevValid' + $lvl, |
|||
$passingSchemas = 'passingSchemas' + $lvl; |
|||
out += 'var ' + ($errs) + ' = errors , ' + ($prevValid) + ' = false , ' + ($valid) + ' = false , ' + ($passingSchemas) + ' = null; '; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
var arr1 = $schema; |
|||
if (arr1) { |
|||
var $sch, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$sch = arr1[$i += 1]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|||
out += ' ' + (it.validate($it)) + ' '; |
|||
$it.baseId = $currentBaseId; |
|||
} else { |
|||
out += ' var ' + ($nextValid) + ' = true; '; |
|||
} |
|||
if ($i) { |
|||
out += ' if (' + ($nextValid) + ' && ' + ($prevValid) + ') { ' + ($valid) + ' = false; ' + ($passingSchemas) + ' = [' + ($passingSchemas) + ', ' + ($i) + ']; } else { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
out += ' if (' + ($nextValid) + ') { ' + ($valid) + ' = ' + ($prevValid) + ' = true; ' + ($passingSchemas) + ' = ' + ($i) + '; }'; |
|||
} |
|||
} |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += '' + ($closingBraces) + 'if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('oneOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { passingSchemas: ' + ($passingSchemas) + ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should match exactly one schema in oneOf\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; return false; '; |
|||
} |
|||
} |
|||
out += '} else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }'; |
|||
if (it.opts.allErrors) { |
|||
out += ' } '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,75 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_pattern(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $regexp = $isData ? '(new RegExp(' + $schemaValue + '))' : it.usePattern($schema); |
|||
out += 'if ( '; |
|||
if ($isData) { |
|||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'string\') || '; |
|||
} |
|||
out += ' !' + ($regexp) + '.test(' + ($data) + ') ) { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('pattern') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { pattern: '; |
|||
if ($isData) { |
|||
out += '' + ($schemaValue); |
|||
} else { |
|||
out += '' + (it.util.toQuotedString($schema)); |
|||
} |
|||
out += ' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should match pattern "'; |
|||
if ($isData) { |
|||
out += '\' + ' + ($schemaValue) + ' + \''; |
|||
} else { |
|||
out += '' + (it.util.escapeQuotes($schema)); |
|||
} |
|||
out += '"\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + (it.util.toQuotedString($schema)); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += '} '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,335 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_properties(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
var $key = 'key' + $lvl, |
|||
$idx = 'idx' + $lvl, |
|||
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|||
$nextData = 'data' + $dataNxt, |
|||
$dataProperties = 'dataProperties' + $lvl; |
|||
var $schemaKeys = Object.keys($schema || {}).filter(notProto), |
|||
$pProperties = it.schema.patternProperties || {}, |
|||
$pPropertyKeys = Object.keys($pProperties).filter(notProto), |
|||
$aProperties = it.schema.additionalProperties, |
|||
$someProperties = $schemaKeys.length || $pPropertyKeys.length, |
|||
$noAdditional = $aProperties === false, |
|||
$additionalIsSchema = typeof $aProperties == 'object' && Object.keys($aProperties).length, |
|||
$removeAdditional = it.opts.removeAdditional, |
|||
$checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, |
|||
$ownProperties = it.opts.ownProperties, |
|||
$currentBaseId = it.baseId; |
|||
var $required = it.schema.required; |
|||
if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) { |
|||
var $requiredHash = it.util.toHash($required); |
|||
} |
|||
|
|||
function notProto(p) { |
|||
return p !== '__proto__'; |
|||
} |
|||
out += 'var ' + ($errs) + ' = errors;var ' + ($nextValid) + ' = true;'; |
|||
if ($ownProperties) { |
|||
out += ' var ' + ($dataProperties) + ' = undefined;'; |
|||
} |
|||
if ($checkAdditional) { |
|||
if ($ownProperties) { |
|||
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|||
} else { |
|||
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|||
} |
|||
if ($someProperties) { |
|||
out += ' var isAdditional' + ($lvl) + ' = !(false '; |
|||
if ($schemaKeys.length) { |
|||
if ($schemaKeys.length > 8) { |
|||
out += ' || validate.schema' + ($schemaPath) + '.hasOwnProperty(' + ($key) + ') '; |
|||
} else { |
|||
var arr1 = $schemaKeys; |
|||
if (arr1) { |
|||
var $propertyKey, i1 = -1, |
|||
l1 = arr1.length - 1; |
|||
while (i1 < l1) { |
|||
$propertyKey = arr1[i1 += 1]; |
|||
out += ' || ' + ($key) + ' == ' + (it.util.toQuotedString($propertyKey)) + ' '; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($pPropertyKeys.length) { |
|||
var arr2 = $pPropertyKeys; |
|||
if (arr2) { |
|||
var $pProperty, $i = -1, |
|||
l2 = arr2.length - 1; |
|||
while ($i < l2) { |
|||
$pProperty = arr2[$i += 1]; |
|||
out += ' || ' + (it.usePattern($pProperty)) + '.test(' + ($key) + ') '; |
|||
} |
|||
} |
|||
} |
|||
out += ' ); if (isAdditional' + ($lvl) + ') { '; |
|||
} |
|||
if ($removeAdditional == 'all') { |
|||
out += ' delete ' + ($data) + '[' + ($key) + ']; '; |
|||
} else { |
|||
var $currentErrorPath = it.errorPath; |
|||
var $additionalProperty = '\' + ' + $key + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
} |
|||
if ($noAdditional) { |
|||
if ($removeAdditional) { |
|||
out += ' delete ' + ($data) + '[' + ($key) + ']; '; |
|||
} else { |
|||
out += ' ' + ($nextValid) + ' = false; '; |
|||
var $currErrSchemaPath = $errSchemaPath; |
|||
$errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('additionalProperties') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { additionalProperty: \'' + ($additionalProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is an invalid additional property'; |
|||
} else { |
|||
out += 'should NOT have additional properties'; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
$errSchemaPath = $currErrSchemaPath; |
|||
if ($breakOnError) { |
|||
out += ' break; '; |
|||
} |
|||
} |
|||
} else if ($additionalIsSchema) { |
|||
if ($removeAdditional == 'failing') { |
|||
out += ' var ' + ($errs) + ' = errors; '; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
$it.schema = $aProperties; |
|||
$it.schemaPath = it.schemaPath + '.additionalProperties'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|||
$it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
var $passData = $data + '[' + $key + ']'; |
|||
$it.dataPathArr[$dataNxt] = $key; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
out += ' if (!' + ($nextValid) + ') { errors = ' + ($errs) + '; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete ' + ($data) + '[' + ($key) + ']; } '; |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
} else { |
|||
$it.schema = $aProperties; |
|||
$it.schemaPath = it.schemaPath + '.additionalProperties'; |
|||
$it.errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|||
$it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
var $passData = $data + '[' + $key + ']'; |
|||
$it.dataPathArr[$dataNxt] = $key; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (!' + ($nextValid) + ') break; '; |
|||
} |
|||
} |
|||
} |
|||
it.errorPath = $currentErrorPath; |
|||
} |
|||
if ($someProperties) { |
|||
out += ' } '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
var $useDefaults = it.opts.useDefaults && !it.compositeRule; |
|||
if ($schemaKeys.length) { |
|||
var arr3 = $schemaKeys; |
|||
if (arr3) { |
|||
var $propertyKey, i3 = -1, |
|||
l3 = arr3.length - 1; |
|||
while (i3 < l3) { |
|||
$propertyKey = arr3[i3 += 1]; |
|||
var $sch = $schema[$propertyKey]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
var $prop = it.util.getProperty($propertyKey), |
|||
$passData = $data + $prop, |
|||
$hasDefault = $useDefaults && $sch.default !== undefined; |
|||
$it.schema = $sch; |
|||
$it.schemaPath = $schemaPath + $prop; |
|||
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey); |
|||
$it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers); |
|||
$it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey); |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
$code = it.util.varReplace($code, $nextData, $passData); |
|||
var $useData = $passData; |
|||
} else { |
|||
var $useData = $nextData; |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; '; |
|||
} |
|||
if ($hasDefault) { |
|||
out += ' ' + ($code) + ' '; |
|||
} else { |
|||
if ($requiredHash && $requiredHash[$propertyKey]) { |
|||
out += ' if ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') { ' + ($nextValid) + ' = false; '; |
|||
var $currentErrorPath = it.errorPath, |
|||
$currErrSchemaPath = $errSchemaPath, |
|||
$missingProperty = it.util.escapeQuotes($propertyKey); |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|||
} |
|||
$errSchemaPath = it.errSchemaPath + '/required'; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
$errSchemaPath = $currErrSchemaPath; |
|||
it.errorPath = $currentErrorPath; |
|||
out += ' } else { '; |
|||
} else { |
|||
if ($breakOnError) { |
|||
out += ' if ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') { ' + ($nextValid) + ' = true; } else { '; |
|||
} else { |
|||
out += ' if (' + ($useData) + ' !== undefined '; |
|||
if ($ownProperties) { |
|||
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ' ) { '; |
|||
} |
|||
} |
|||
out += ' ' + ($code) + ' } '; |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($pPropertyKeys.length) { |
|||
var arr4 = $pPropertyKeys; |
|||
if (arr4) { |
|||
var $pProperty, i4 = -1, |
|||
l4 = arr4.length - 1; |
|||
while (i4 < l4) { |
|||
$pProperty = arr4[i4 += 1]; |
|||
var $sch = $pProperties[$pProperty]; |
|||
if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) { |
|||
$it.schema = $sch; |
|||
$it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty); |
|||
$it.errSchemaPath = it.errSchemaPath + '/patternProperties/' + it.util.escapeFragment($pProperty); |
|||
if ($ownProperties) { |
|||
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|||
} else { |
|||
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|||
} |
|||
out += ' if (' + (it.usePattern($pProperty)) + '.test(' + ($key) + ')) { '; |
|||
$it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|||
var $passData = $data + '[' + $key + ']'; |
|||
$it.dataPathArr[$dataNxt] = $key; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (!' + ($nextValid) + ') break; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else ' + ($nextValid) + ' = true; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
$closingBraces += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,81 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_propertyNames(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $errs = 'errs__' + $lvl; |
|||
var $it = it.util.copy(it); |
|||
var $closingBraces = ''; |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
out += 'var ' + ($errs) + ' = errors;'; |
|||
if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) { |
|||
$it.schema = $schema; |
|||
$it.schemaPath = $schemaPath; |
|||
$it.errSchemaPath = $errSchemaPath; |
|||
var $key = 'key' + $lvl, |
|||
$idx = 'idx' + $lvl, |
|||
$i = 'i' + $lvl, |
|||
$invalidName = '\' + ' + $key + ' + \'', |
|||
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|||
$nextData = 'data' + $dataNxt, |
|||
$dataProperties = 'dataProperties' + $lvl, |
|||
$ownProperties = it.opts.ownProperties, |
|||
$currentBaseId = it.baseId; |
|||
if ($ownProperties) { |
|||
out += ' var ' + ($dataProperties) + ' = undefined; '; |
|||
} |
|||
if ($ownProperties) { |
|||
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|||
} else { |
|||
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|||
} |
|||
out += ' var startErrs' + ($lvl) + ' = errors; '; |
|||
var $passData = $key; |
|||
var $wasComposite = it.compositeRule; |
|||
it.compositeRule = $it.compositeRule = true; |
|||
var $code = it.validate($it); |
|||
$it.baseId = $currentBaseId; |
|||
if (it.util.varOccurences($code, $nextData) < 2) { |
|||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|||
} else { |
|||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|||
} |
|||
it.compositeRule = $it.compositeRule = $wasComposite; |
|||
out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; } var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('propertyNames') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \'' + ($invalidName) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'property name \\\'' + ($invalidName) + '\\\' is invalid\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; return false; '; |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' break; '; |
|||
} |
|||
out += ' } }'; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,124 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_ref(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $async, $refCode; |
|||
if ($schema == '#' || $schema == '#/') { |
|||
if (it.isRoot) { |
|||
$async = it.async; |
|||
$refCode = 'validate'; |
|||
} else { |
|||
$async = it.root.schema.$async === true; |
|||
$refCode = 'root.refVal[0]'; |
|||
} |
|||
} else { |
|||
var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot); |
|||
if ($refVal === undefined) { |
|||
var $message = it.MissingRefError.message(it.baseId, $schema); |
|||
if (it.opts.missingRefs == 'fail') { |
|||
it.logger.error($message); |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('$ref') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { ref: \'' + (it.util.escapeQuotes($schema)) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'can\\\'t resolve reference ' + (it.util.escapeQuotes($schema)) + '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: ' + (it.util.toQuotedString($schema)) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (false) { '; |
|||
} |
|||
} else if (it.opts.missingRefs == 'ignore') { |
|||
it.logger.warn($message); |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
} else { |
|||
throw new it.MissingRefError(it.baseId, $schema, $message); |
|||
} |
|||
} else if ($refVal.inline) { |
|||
var $it = it.util.copy(it); |
|||
$it.level++; |
|||
var $nextValid = 'valid' + $it.level; |
|||
$it.schema = $refVal.schema; |
|||
$it.schemaPath = ''; |
|||
$it.errSchemaPath = $schema; |
|||
var $code = it.validate($it).replace(/validate\.schema/g, $refVal.code); |
|||
out += ' ' + ($code) + ' '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($nextValid) + ') { '; |
|||
} |
|||
} else { |
|||
$async = $refVal.$async === true || (it.async && $refVal.$async !== false); |
|||
$refCode = $refVal.code; |
|||
} |
|||
} |
|||
if ($refCode) { |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; |
|||
if (it.opts.passContext) { |
|||
out += ' ' + ($refCode) + '.call(this, '; |
|||
} else { |
|||
out += ' ' + ($refCode) + '( '; |
|||
} |
|||
out += ' ' + ($data) + ', (dataPath || \'\')'; |
|||
if (it.errorPath != '""') { |
|||
out += ' + ' + (it.errorPath); |
|||
} |
|||
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|||
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|||
out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ', rootData) '; |
|||
var __callValidate = out; |
|||
out = $$outStack.pop(); |
|||
if ($async) { |
|||
if (!it.async) throw new Error('async schema referenced by sync schema'); |
|||
if ($breakOnError) { |
|||
out += ' var ' + ($valid) + '; '; |
|||
} |
|||
out += ' try { await ' + (__callValidate) + '; '; |
|||
if ($breakOnError) { |
|||
out += ' ' + ($valid) + ' = true; '; |
|||
} |
|||
out += ' } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; '; |
|||
if ($breakOnError) { |
|||
out += ' ' + ($valid) + ' = false; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' if (' + ($valid) + ') { '; |
|||
} |
|||
} else { |
|||
out += ' if (!' + (__callValidate) + ') { if (vErrors === null) vErrors = ' + ($refCode) + '.errors; else vErrors = vErrors.concat(' + ($refCode) + '.errors); errors = vErrors.length; } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,270 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_required(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
var $vSchema = 'schema' + $lvl; |
|||
if (!$isData) { |
|||
if ($schema.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) { |
|||
var $required = []; |
|||
var arr1 = $schema; |
|||
if (arr1) { |
|||
var $property, i1 = -1, |
|||
l1 = arr1.length - 1; |
|||
while (i1 < l1) { |
|||
$property = arr1[i1 += 1]; |
|||
var $propertySch = it.schema.properties[$property]; |
|||
if (!($propertySch && (it.opts.strictKeywords ? (typeof $propertySch == 'object' && Object.keys($propertySch).length > 0) || $propertySch === false : it.util.schemaHasRules($propertySch, it.RULES.all)))) { |
|||
$required[$required.length] = $property; |
|||
} |
|||
} |
|||
} |
|||
} else { |
|||
var $required = $schema; |
|||
} |
|||
} |
|||
if ($isData || $required.length) { |
|||
var $currentErrorPath = it.errorPath, |
|||
$loopRequired = $isData || $required.length >= it.opts.loopRequired, |
|||
$ownProperties = it.opts.ownProperties; |
|||
if ($breakOnError) { |
|||
out += ' var missing' + ($lvl) + '; '; |
|||
if ($loopRequired) { |
|||
if (!$isData) { |
|||
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; '; |
|||
} |
|||
var $i = 'i' + $lvl, |
|||
$propertyPath = 'schema' + $lvl + '[' + $i + ']', |
|||
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); |
|||
} |
|||
out += ' var ' + ($valid) + ' = true; '; |
|||
if ($isData) { |
|||
out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {'; |
|||
} |
|||
out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { ' + ($valid) + ' = ' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] !== undefined '; |
|||
if ($ownProperties) { |
|||
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) '; |
|||
} |
|||
out += '; if (!' + ($valid) + ') break; } '; |
|||
if ($isData) { |
|||
out += ' } '; |
|||
} |
|||
out += ' if (!' + ($valid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } else { '; |
|||
} else { |
|||
out += ' if ( '; |
|||
var arr2 = $required; |
|||
if (arr2) { |
|||
var $propertyKey, $i = -1, |
|||
l2 = arr2.length - 1; |
|||
while ($i < l2) { |
|||
$propertyKey = arr2[$i += 1]; |
|||
if ($i) { |
|||
out += ' || '; |
|||
} |
|||
var $prop = it.util.getProperty($propertyKey), |
|||
$useData = $data + $prop; |
|||
out += ' ( ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) '; |
|||
} |
|||
} |
|||
out += ') { '; |
|||
var $propertyPath = 'missing' + $lvl, |
|||
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath; |
|||
} |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } else { '; |
|||
} |
|||
} else { |
|||
if ($loopRequired) { |
|||
if (!$isData) { |
|||
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; '; |
|||
} |
|||
var $i = 'i' + $lvl, |
|||
$propertyPath = 'schema' + $lvl + '[' + $i + ']', |
|||
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); |
|||
} |
|||
if ($isData) { |
|||
out += ' if (' + ($vSchema) + ' && !Array.isArray(' + ($vSchema) + ')) { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (' + ($vSchema) + ' !== undefined) { '; |
|||
} |
|||
out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { if (' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) '; |
|||
} |
|||
out += ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } '; |
|||
if ($isData) { |
|||
out += ' } '; |
|||
} |
|||
} else { |
|||
var arr3 = $required; |
|||
if (arr3) { |
|||
var $propertyKey, i3 = -1, |
|||
l3 = arr3.length - 1; |
|||
while (i3 < l3) { |
|||
$propertyKey = arr3[i3 += 1]; |
|||
var $prop = it.util.getProperty($propertyKey), |
|||
$missingProperty = it.util.escapeQuotes($propertyKey), |
|||
$useData = $data + $prop; |
|||
if (it.opts._errorDataPathProperty) { |
|||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|||
} |
|||
out += ' if ( ' + ($useData) + ' === undefined '; |
|||
if ($ownProperties) { |
|||
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|||
} |
|||
out += ') { var err = '; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \''; |
|||
if (it.opts._errorDataPathProperty) { |
|||
out += 'is a required property'; |
|||
} else { |
|||
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } '; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
it.errorPath = $currentErrorPath; |
|||
} else if ($breakOnError) { |
|||
out += ' if (true) {'; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,86 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_uniqueItems(it, $keyword, $ruleType) { |
|||
var out = ' '; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
var $isData = it.opts.$data && $schema && $schema.$data, |
|||
$schemaValue; |
|||
if ($isData) { |
|||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|||
$schemaValue = 'schema' + $lvl; |
|||
} else { |
|||
$schemaValue = $schema; |
|||
} |
|||
if (($schema || $isData) && it.opts.uniqueItems !== false) { |
|||
if ($isData) { |
|||
out += ' var ' + ($valid) + '; if (' + ($schemaValue) + ' === false || ' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \'boolean\') ' + ($valid) + ' = false; else { '; |
|||
} |
|||
out += ' var i = ' + ($data) + '.length , ' + ($valid) + ' = true , j; if (i > 1) { '; |
|||
var $itemType = it.schema.items && it.schema.items.type, |
|||
$typeIsArray = Array.isArray($itemType); |
|||
if (!$itemType || $itemType == 'object' || $itemType == 'array' || ($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0))) { |
|||
out += ' outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } '; |
|||
} else { |
|||
out += ' var itemIndices = {}, item; for (;i--;) { var item = ' + ($data) + '[i]; '; |
|||
var $method = 'checkDataType' + ($typeIsArray ? 's' : ''); |
|||
out += ' if (' + (it.util[$method]($itemType, 'item', it.opts.strictNumbers, true)) + ') continue; '; |
|||
if ($typeIsArray) { |
|||
out += ' if (typeof item == \'string\') item = \'"\' + item; '; |
|||
} |
|||
out += ' if (typeof itemIndices[item] == \'number\') { ' + ($valid) + ' = false; j = itemIndices[item]; break; } itemIndices[item] = i; } '; |
|||
} |
|||
out += ' } '; |
|||
if ($isData) { |
|||
out += ' } '; |
|||
} |
|||
out += ' if (!' + ($valid) + ') { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ('uniqueItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { i: i, j: j } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should NOT have duplicate items (items ## \' + j + \' and \' + i + \' are identical)\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: '; |
|||
if ($isData) { |
|||
out += 'validate.schema' + ($schemaPath); |
|||
} else { |
|||
out += '' + ($schema); |
|||
} |
|||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } '; |
|||
if ($breakOnError) { |
|||
out += ' else { '; |
|||
} |
|||
} else { |
|||
if ($breakOnError) { |
|||
out += ' if (true) { '; |
|||
} |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,482 +0,0 @@ |
|||
'use strict'; |
|||
module.exports = function generate_validate(it, $keyword, $ruleType) { |
|||
var out = ''; |
|||
var $async = it.schema.$async === true, |
|||
$refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref'), |
|||
$id = it.self._getId(it.schema); |
|||
if (it.opts.strictKeywords) { |
|||
var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords); |
|||
if ($unknownKwd) { |
|||
var $keywordsMsg = 'unknown keyword: ' + $unknownKwd; |
|||
if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg); |
|||
else throw new Error($keywordsMsg); |
|||
} |
|||
} |
|||
if (it.isTop) { |
|||
out += ' var validate = '; |
|||
if ($async) { |
|||
it.async = true; |
|||
out += 'async '; |
|||
} |
|||
out += 'function(data, dataPath, parentData, parentDataProperty, rootData) { \'use strict\'; '; |
|||
if ($id && (it.opts.sourceCode || it.opts.processCode)) { |
|||
out += ' ' + ('/\*# sourceURL=' + $id + ' */') + ' '; |
|||
} |
|||
} |
|||
if (typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref)) { |
|||
var $keyword = 'false schema'; |
|||
var $lvl = it.level; |
|||
var $dataLvl = it.dataLevel; |
|||
var $schema = it.schema[$keyword]; |
|||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|||
var $breakOnError = !it.opts.allErrors; |
|||
var $errorKeyword; |
|||
var $data = 'data' + ($dataLvl || ''); |
|||
var $valid = 'valid' + $lvl; |
|||
if (it.schema === false) { |
|||
if (it.isTop) { |
|||
$breakOnError = true; |
|||
} else { |
|||
out += ' var ' + ($valid) + ' = false; '; |
|||
} |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'false schema') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'boolean schema is false\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
} else { |
|||
if (it.isTop) { |
|||
if ($async) { |
|||
out += ' return data; '; |
|||
} else { |
|||
out += ' validate.errors = null; return true; '; |
|||
} |
|||
} else { |
|||
out += ' var ' + ($valid) + ' = true; '; |
|||
} |
|||
} |
|||
if (it.isTop) { |
|||
out += ' }; return validate; '; |
|||
} |
|||
return out; |
|||
} |
|||
if (it.isTop) { |
|||
var $top = it.isTop, |
|||
$lvl = it.level = 0, |
|||
$dataLvl = it.dataLevel = 0, |
|||
$data = 'data'; |
|||
it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema)); |
|||
it.baseId = it.baseId || it.rootId; |
|||
delete it.isTop; |
|||
it.dataPathArr = [""]; |
|||
if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) { |
|||
var $defaultMsg = 'default is ignored in the schema root'; |
|||
if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
|||
else throw new Error($defaultMsg); |
|||
} |
|||
out += ' var vErrors = null; '; |
|||
out += ' var errors = 0; '; |
|||
out += ' if (rootData === undefined) rootData = data; '; |
|||
} else { |
|||
var $lvl = it.level, |
|||
$dataLvl = it.dataLevel, |
|||
$data = 'data' + ($dataLvl || ''); |
|||
if ($id) it.baseId = it.resolve.url(it.baseId, $id); |
|||
if ($async && !it.async) throw new Error('async schema in sync schema'); |
|||
out += ' var errs_' + ($lvl) + ' = errors;'; |
|||
} |
|||
var $valid = 'valid' + $lvl, |
|||
$breakOnError = !it.opts.allErrors, |
|||
$closingBraces1 = '', |
|||
$closingBraces2 = ''; |
|||
var $errorKeyword; |
|||
var $typeSchema = it.schema.type, |
|||
$typeIsArray = Array.isArray($typeSchema); |
|||
if ($typeSchema && it.opts.nullable && it.schema.nullable === true) { |
|||
if ($typeIsArray) { |
|||
if ($typeSchema.indexOf('null') == -1) $typeSchema = $typeSchema.concat('null'); |
|||
} else if ($typeSchema != 'null') { |
|||
$typeSchema = [$typeSchema, 'null']; |
|||
$typeIsArray = true; |
|||
} |
|||
} |
|||
if ($typeIsArray && $typeSchema.length == 1) { |
|||
$typeSchema = $typeSchema[0]; |
|||
$typeIsArray = false; |
|||
} |
|||
if (it.schema.$ref && $refKeywords) { |
|||
if (it.opts.extendRefs == 'fail') { |
|||
throw new Error('$ref: validation keywords used in schema at path "' + it.errSchemaPath + '" (see option extendRefs)'); |
|||
} else if (it.opts.extendRefs !== true) { |
|||
$refKeywords = false; |
|||
it.logger.warn('$ref: keywords ignored in schema at path "' + it.errSchemaPath + '"'); |
|||
} |
|||
} |
|||
if (it.schema.$comment && it.opts.$comment) { |
|||
out += ' ' + (it.RULES.all.$comment.code(it, '$comment')); |
|||
} |
|||
if ($typeSchema) { |
|||
if (it.opts.coerceTypes) { |
|||
var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema); |
|||
} |
|||
var $rulesGroup = it.RULES.types[$typeSchema]; |
|||
if ($coerceToTypes || $typeIsArray || $rulesGroup === true || ($rulesGroup && !$shouldUseGroup($rulesGroup))) { |
|||
var $schemaPath = it.schemaPath + '.type', |
|||
$errSchemaPath = it.errSchemaPath + '/type'; |
|||
var $schemaPath = it.schemaPath + '.type', |
|||
$errSchemaPath = it.errSchemaPath + '/type', |
|||
$method = $typeIsArray ? 'checkDataTypes' : 'checkDataType'; |
|||
out += ' if (' + (it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true)) + ') { '; |
|||
if ($coerceToTypes) { |
|||
var $dataType = 'dataType' + $lvl, |
|||
$coerced = 'coerced' + $lvl; |
|||
out += ' var ' + ($dataType) + ' = typeof ' + ($data) + '; var ' + ($coerced) + ' = undefined; '; |
|||
if (it.opts.coerceTypes == 'array') { |
|||
out += ' if (' + ($dataType) + ' == \'object\' && Array.isArray(' + ($data) + ') && ' + ($data) + '.length == 1) { ' + ($data) + ' = ' + ($data) + '[0]; ' + ($dataType) + ' = typeof ' + ($data) + '; if (' + (it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers)) + ') ' + ($coerced) + ' = ' + ($data) + '; } '; |
|||
} |
|||
out += ' if (' + ($coerced) + ' !== undefined) ; '; |
|||
var arr1 = $coerceToTypes; |
|||
if (arr1) { |
|||
var $type, $i = -1, |
|||
l1 = arr1.length - 1; |
|||
while ($i < l1) { |
|||
$type = arr1[$i += 1]; |
|||
if ($type == 'string') { |
|||
out += ' else if (' + ($dataType) + ' == \'number\' || ' + ($dataType) + ' == \'boolean\') ' + ($coerced) + ' = \'\' + ' + ($data) + '; else if (' + ($data) + ' === null) ' + ($coerced) + ' = \'\'; '; |
|||
} else if ($type == 'number' || $type == 'integer') { |
|||
out += ' else if (' + ($dataType) + ' == \'boolean\' || ' + ($data) + ' === null || (' + ($dataType) + ' == \'string\' && ' + ($data) + ' && ' + ($data) + ' == +' + ($data) + ' '; |
|||
if ($type == 'integer') { |
|||
out += ' && !(' + ($data) + ' % 1)'; |
|||
} |
|||
out += ')) ' + ($coerced) + ' = +' + ($data) + '; '; |
|||
} else if ($type == 'boolean') { |
|||
out += ' else if (' + ($data) + ' === \'false\' || ' + ($data) + ' === 0 || ' + ($data) + ' === null) ' + ($coerced) + ' = false; else if (' + ($data) + ' === \'true\' || ' + ($data) + ' === 1) ' + ($coerced) + ' = true; '; |
|||
} else if ($type == 'null') { |
|||
out += ' else if (' + ($data) + ' === \'\' || ' + ($data) + ' === 0 || ' + ($data) + ' === false) ' + ($coerced) + ' = null; '; |
|||
} else if (it.opts.coerceTypes == 'array' && $type == 'array') { |
|||
out += ' else if (' + ($dataType) + ' == \'string\' || ' + ($dataType) + ' == \'number\' || ' + ($dataType) + ' == \'boolean\' || ' + ($data) + ' == null) ' + ($coerced) + ' = [' + ($data) + ']; '; |
|||
} |
|||
} |
|||
} |
|||
out += ' else { '; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be '; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } if (' + ($coerced) + ' !== undefined) { '; |
|||
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|||
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|||
out += ' ' + ($data) + ' = ' + ($coerced) + '; '; |
|||
if (!$dataLvl) { |
|||
out += 'if (' + ($parentData) + ' !== undefined)'; |
|||
} |
|||
out += ' ' + ($parentData) + '[' + ($parentDataProperty) + '] = ' + ($coerced) + '; } '; |
|||
} else { |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be '; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
} |
|||
out += ' } '; |
|||
} |
|||
} |
|||
if (it.schema.$ref && !$refKeywords) { |
|||
out += ' ' + (it.RULES.all.$ref.code(it, '$ref')) + ' '; |
|||
if ($breakOnError) { |
|||
out += ' } if (errors === '; |
|||
if ($top) { |
|||
out += '0'; |
|||
} else { |
|||
out += 'errs_' + ($lvl); |
|||
} |
|||
out += ') { '; |
|||
$closingBraces2 += '}'; |
|||
} |
|||
} else { |
|||
var arr2 = it.RULES; |
|||
if (arr2) { |
|||
var $rulesGroup, i2 = -1, |
|||
l2 = arr2.length - 1; |
|||
while (i2 < l2) { |
|||
$rulesGroup = arr2[i2 += 1]; |
|||
if ($shouldUseGroup($rulesGroup)) { |
|||
if ($rulesGroup.type) { |
|||
out += ' if (' + (it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers)) + ') { '; |
|||
} |
|||
if (it.opts.useDefaults) { |
|||
if ($rulesGroup.type == 'object' && it.schema.properties) { |
|||
var $schema = it.schema.properties, |
|||
$schemaKeys = Object.keys($schema); |
|||
var arr3 = $schemaKeys; |
|||
if (arr3) { |
|||
var $propertyKey, i3 = -1, |
|||
l3 = arr3.length - 1; |
|||
while (i3 < l3) { |
|||
$propertyKey = arr3[i3 += 1]; |
|||
var $sch = $schema[$propertyKey]; |
|||
if ($sch.default !== undefined) { |
|||
var $passData = $data + it.util.getProperty($propertyKey); |
|||
if (it.compositeRule) { |
|||
if (it.opts.strictDefaults) { |
|||
var $defaultMsg = 'default is ignored for: ' + $passData; |
|||
if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
|||
else throw new Error($defaultMsg); |
|||
} |
|||
} else { |
|||
out += ' if (' + ($passData) + ' === undefined '; |
|||
if (it.opts.useDefaults == 'empty') { |
|||
out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \'\' '; |
|||
} |
|||
out += ' ) ' + ($passData) + ' = '; |
|||
if (it.opts.useDefaults == 'shared') { |
|||
out += ' ' + (it.useDefault($sch.default)) + ' '; |
|||
} else { |
|||
out += ' ' + (JSON.stringify($sch.default)) + ' '; |
|||
} |
|||
out += '; '; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} else if ($rulesGroup.type == 'array' && Array.isArray(it.schema.items)) { |
|||
var arr4 = it.schema.items; |
|||
if (arr4) { |
|||
var $sch, $i = -1, |
|||
l4 = arr4.length - 1; |
|||
while ($i < l4) { |
|||
$sch = arr4[$i += 1]; |
|||
if ($sch.default !== undefined) { |
|||
var $passData = $data + '[' + $i + ']'; |
|||
if (it.compositeRule) { |
|||
if (it.opts.strictDefaults) { |
|||
var $defaultMsg = 'default is ignored for: ' + $passData; |
|||
if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
|||
else throw new Error($defaultMsg); |
|||
} |
|||
} else { |
|||
out += ' if (' + ($passData) + ' === undefined '; |
|||
if (it.opts.useDefaults == 'empty') { |
|||
out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \'\' '; |
|||
} |
|||
out += ' ) ' + ($passData) + ' = '; |
|||
if (it.opts.useDefaults == 'shared') { |
|||
out += ' ' + (it.useDefault($sch.default)) + ' '; |
|||
} else { |
|||
out += ' ' + (JSON.stringify($sch.default)) + ' '; |
|||
} |
|||
out += '; '; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
var arr5 = $rulesGroup.rules; |
|||
if (arr5) { |
|||
var $rule, i5 = -1, |
|||
l5 = arr5.length - 1; |
|||
while (i5 < l5) { |
|||
$rule = arr5[i5 += 1]; |
|||
if ($shouldUseRule($rule)) { |
|||
var $code = $rule.code(it, $rule.keyword, $rulesGroup.type); |
|||
if ($code) { |
|||
out += ' ' + ($code) + ' '; |
|||
if ($breakOnError) { |
|||
$closingBraces1 += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces1) + ' '; |
|||
$closingBraces1 = ''; |
|||
} |
|||
if ($rulesGroup.type) { |
|||
out += ' } '; |
|||
if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) { |
|||
out += ' else { '; |
|||
var $schemaPath = it.schemaPath + '.type', |
|||
$errSchemaPath = it.errSchemaPath + '/type'; |
|||
var $$outStack = $$outStack || []; |
|||
$$outStack.push(out); |
|||
out = ''; /* istanbul ignore else */ |
|||
if (it.createErrors !== false) { |
|||
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' } '; |
|||
if (it.opts.messages !== false) { |
|||
out += ' , message: \'should be '; |
|||
if ($typeIsArray) { |
|||
out += '' + ($typeSchema.join(",")); |
|||
} else { |
|||
out += '' + ($typeSchema); |
|||
} |
|||
out += '\' '; |
|||
} |
|||
if (it.opts.verbose) { |
|||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|||
} |
|||
out += ' } '; |
|||
} else { |
|||
out += ' {} '; |
|||
} |
|||
var __err = out; |
|||
out = $$outStack.pop(); |
|||
if (!it.compositeRule && $breakOnError) { |
|||
/* istanbul ignore if */ |
|||
if (it.async) { |
|||
out += ' throw new ValidationError([' + (__err) + ']); '; |
|||
} else { |
|||
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|||
} |
|||
} else { |
|||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|||
} |
|||
out += ' } '; |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' if (errors === '; |
|||
if ($top) { |
|||
out += '0'; |
|||
} else { |
|||
out += 'errs_' + ($lvl); |
|||
} |
|||
out += ') { '; |
|||
$closingBraces2 += '}'; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ($breakOnError) { |
|||
out += ' ' + ($closingBraces2) + ' '; |
|||
} |
|||
if ($top) { |
|||
if ($async) { |
|||
out += ' if (errors === 0) return data; '; |
|||
out += ' else throw new ValidationError(vErrors); '; |
|||
} else { |
|||
out += ' validate.errors = vErrors; '; |
|||
out += ' return errors === 0; '; |
|||
} |
|||
out += ' }; return validate;'; |
|||
} else { |
|||
out += ' var ' + ($valid) + ' = errors === errs_' + ($lvl) + ';'; |
|||
} |
|||
|
|||
function $shouldUseGroup($rulesGroup) { |
|||
var rules = $rulesGroup.rules; |
|||
for (var i = 0; i < rules.length; i++) |
|||
if ($shouldUseRule(rules[i])) return true; |
|||
} |
|||
|
|||
function $shouldUseRule($rule) { |
|||
return it.schema[$rule.keyword] !== undefined || ($rule.implements && $ruleImplementsSomeKeyword($rule)); |
|||
} |
|||
|
|||
function $ruleImplementsSomeKeyword($rule) { |
|||
var impl = $rule.implements; |
|||
for (var i = 0; i < impl.length; i++) |
|||
if (it.schema[impl[i]] !== undefined) return true; |
|||
} |
|||
return out; |
|||
} |
|||
@ -1,146 +0,0 @@ |
|||
'use strict'; |
|||
|
|||
var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i; |
|||
var customRuleCode = require('./dotjs/custom'); |
|||
var definitionSchema = require('./definition_schema'); |
|||
|
|||
module.exports = { |
|||
add: addKeyword, |
|||
get: getKeyword, |
|||
remove: removeKeyword, |
|||
validate: validateKeyword |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Define custom keyword |
|||
* @this Ajv |
|||
* @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords). |
|||
* @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function addKeyword(keyword, definition) { |
|||
/* jshint validthis: true */ |
|||
/* eslint no-shadow: 0 */ |
|||
var RULES = this.RULES; |
|||
if (RULES.keywords[keyword]) |
|||
throw new Error('Keyword ' + keyword + ' is already defined'); |
|||
|
|||
if (!IDENTIFIER.test(keyword)) |
|||
throw new Error('Keyword ' + keyword + ' is not a valid identifier'); |
|||
|
|||
if (definition) { |
|||
this.validateKeyword(definition, true); |
|||
|
|||
var dataType = definition.type; |
|||
if (Array.isArray(dataType)) { |
|||
for (var i=0; i<dataType.length; i++) |
|||
_addRule(keyword, dataType[i], definition); |
|||
} else { |
|||
_addRule(keyword, dataType, definition); |
|||
} |
|||
|
|||
var metaSchema = definition.metaSchema; |
|||
if (metaSchema) { |
|||
if (definition.$data && this._opts.$data) { |
|||
metaSchema = { |
|||
anyOf: [ |
|||
metaSchema, |
|||
{ '$ref': 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' } |
|||
] |
|||
}; |
|||
} |
|||
definition.validateSchema = this.compile(metaSchema, true); |
|||
} |
|||
} |
|||
|
|||
RULES.keywords[keyword] = RULES.all[keyword] = true; |
|||
|
|||
|
|||
function _addRule(keyword, dataType, definition) { |
|||
var ruleGroup; |
|||
for (var i=0; i<RULES.length; i++) { |
|||
var rg = RULES[i]; |
|||
if (rg.type == dataType) { |
|||
ruleGroup = rg; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (!ruleGroup) { |
|||
ruleGroup = { type: dataType, rules: [] }; |
|||
RULES.push(ruleGroup); |
|||
} |
|||
|
|||
var rule = { |
|||
keyword: keyword, |
|||
definition: definition, |
|||
custom: true, |
|||
code: customRuleCode, |
|||
implements: definition.implements |
|||
}; |
|||
ruleGroup.rules.push(rule); |
|||
RULES.custom[keyword] = rule; |
|||
} |
|||
|
|||
return this; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Get keyword |
|||
* @this Ajv |
|||
* @param {String} keyword pre-defined or custom keyword. |
|||
* @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise. |
|||
*/ |
|||
function getKeyword(keyword) { |
|||
/* jshint validthis: true */ |
|||
var rule = this.RULES.custom[keyword]; |
|||
return rule ? rule.definition : this.RULES.keywords[keyword] || false; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Remove keyword |
|||
* @this Ajv |
|||
* @param {String} keyword pre-defined or custom keyword. |
|||
* @return {Ajv} this for method chaining |
|||
*/ |
|||
function removeKeyword(keyword) { |
|||
/* jshint validthis: true */ |
|||
var RULES = this.RULES; |
|||
delete RULES.keywords[keyword]; |
|||
delete RULES.all[keyword]; |
|||
delete RULES.custom[keyword]; |
|||
for (var i=0; i<RULES.length; i++) { |
|||
var rules = RULES[i].rules; |
|||
for (var j=0; j<rules.length; j++) { |
|||
if (rules[j].keyword == keyword) { |
|||
rules.splice(j, 1); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
return this; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Validate keyword definition |
|||
* @this Ajv |
|||
* @param {Object} definition keyword definition object. |
|||
* @param {Boolean} throwError true to throw exception if definition is invalid |
|||
* @return {boolean} validation result |
|||
*/ |
|||
function validateKeyword(definition, throwError) { |
|||
validateKeyword.errors = null; |
|||
var v = this._validateKeyword = this._validateKeyword |
|||
|| this.compile(definitionSchema, true); |
|||
|
|||
if (v(definition)) return true; |
|||
validateKeyword.errors = v.errors; |
|||
if (throwError) |
|||
throw new Error('custom keyword definition is invalid: ' + this.errorsText(v.errors)); |
|||
else |
|||
return false; |
|||
} |
|||
@ -1,17 +0,0 @@ |
|||
{ |
|||
"$schema": "http://json-schema.org/draft-07/schema#", |
|||
"$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", |
|||
"description": "Meta-schema for $data reference (JSON Schema extension proposal)", |
|||
"type": "object", |
|||
"required": [ "$data" ], |
|||
"properties": { |
|||
"$data": { |
|||
"type": "string", |
|||
"anyOf": [ |
|||
{ "format": "relative-json-pointer" }, |
|||
{ "format": "json-pointer" } |
|||
] |
|||
} |
|||
}, |
|||
"additionalProperties": false |
|||
} |
|||
@ -1,149 +0,0 @@ |
|||
{ |
|||
"id": "http://json-schema.org/draft-04/schema#", |
|||
"$schema": "http://json-schema.org/draft-04/schema#", |
|||
"description": "Core schema meta-schema", |
|||
"definitions": { |
|||
"schemaArray": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"items": { "$ref": "#" } |
|||
}, |
|||
"positiveInteger": { |
|||
"type": "integer", |
|||
"minimum": 0 |
|||
}, |
|||
"positiveIntegerDefault0": { |
|||
"allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ] |
|||
}, |
|||
"simpleTypes": { |
|||
"enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] |
|||
}, |
|||
"stringArray": { |
|||
"type": "array", |
|||
"items": { "type": "string" }, |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
} |
|||
}, |
|||
"type": "object", |
|||
"properties": { |
|||
"id": { |
|||
"type": "string" |
|||
}, |
|||
"$schema": { |
|||
"type": "string" |
|||
}, |
|||
"title": { |
|||
"type": "string" |
|||
}, |
|||
"description": { |
|||
"type": "string" |
|||
}, |
|||
"default": {}, |
|||
"multipleOf": { |
|||
"type": "number", |
|||
"minimum": 0, |
|||
"exclusiveMinimum": true |
|||
}, |
|||
"maximum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMaximum": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"minimum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMinimum": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"maxLength": { "$ref": "#/definitions/positiveInteger" }, |
|||
"minLength": { "$ref": "#/definitions/positiveIntegerDefault0" }, |
|||
"pattern": { |
|||
"type": "string", |
|||
"format": "regex" |
|||
}, |
|||
"additionalItems": { |
|||
"anyOf": [ |
|||
{ "type": "boolean" }, |
|||
{ "$ref": "#" } |
|||
], |
|||
"default": {} |
|||
}, |
|||
"items": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/schemaArray" } |
|||
], |
|||
"default": {} |
|||
}, |
|||
"maxItems": { "$ref": "#/definitions/positiveInteger" }, |
|||
"minItems": { "$ref": "#/definitions/positiveIntegerDefault0" }, |
|||
"uniqueItems": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"maxProperties": { "$ref": "#/definitions/positiveInteger" }, |
|||
"minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" }, |
|||
"required": { "$ref": "#/definitions/stringArray" }, |
|||
"additionalProperties": { |
|||
"anyOf": [ |
|||
{ "type": "boolean" }, |
|||
{ "$ref": "#" } |
|||
], |
|||
"default": {} |
|||
}, |
|||
"definitions": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"properties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"patternProperties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"dependencies": { |
|||
"type": "object", |
|||
"additionalProperties": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/stringArray" } |
|||
] |
|||
} |
|||
}, |
|||
"enum": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
}, |
|||
"type": { |
|||
"anyOf": [ |
|||
{ "$ref": "#/definitions/simpleTypes" }, |
|||
{ |
|||
"type": "array", |
|||
"items": { "$ref": "#/definitions/simpleTypes" }, |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
} |
|||
] |
|||
}, |
|||
"format": { "type": "string" }, |
|||
"allOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"anyOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"oneOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"not": { "$ref": "#" } |
|||
}, |
|||
"dependencies": { |
|||
"exclusiveMaximum": [ "maximum" ], |
|||
"exclusiveMinimum": [ "minimum" ] |
|||
}, |
|||
"default": {} |
|||
} |
|||
@ -1,154 +0,0 @@ |
|||
{ |
|||
"$schema": "http://json-schema.org/draft-06/schema#", |
|||
"$id": "http://json-schema.org/draft-06/schema#", |
|||
"title": "Core schema meta-schema", |
|||
"definitions": { |
|||
"schemaArray": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"items": { "$ref": "#" } |
|||
}, |
|||
"nonNegativeInteger": { |
|||
"type": "integer", |
|||
"minimum": 0 |
|||
}, |
|||
"nonNegativeIntegerDefault0": { |
|||
"allOf": [ |
|||
{ "$ref": "#/definitions/nonNegativeInteger" }, |
|||
{ "default": 0 } |
|||
] |
|||
}, |
|||
"simpleTypes": { |
|||
"enum": [ |
|||
"array", |
|||
"boolean", |
|||
"integer", |
|||
"null", |
|||
"number", |
|||
"object", |
|||
"string" |
|||
] |
|||
}, |
|||
"stringArray": { |
|||
"type": "array", |
|||
"items": { "type": "string" }, |
|||
"uniqueItems": true, |
|||
"default": [] |
|||
} |
|||
}, |
|||
"type": ["object", "boolean"], |
|||
"properties": { |
|||
"$id": { |
|||
"type": "string", |
|||
"format": "uri-reference" |
|||
}, |
|||
"$schema": { |
|||
"type": "string", |
|||
"format": "uri" |
|||
}, |
|||
"$ref": { |
|||
"type": "string", |
|||
"format": "uri-reference" |
|||
}, |
|||
"title": { |
|||
"type": "string" |
|||
}, |
|||
"description": { |
|||
"type": "string" |
|||
}, |
|||
"default": {}, |
|||
"examples": { |
|||
"type": "array", |
|||
"items": {} |
|||
}, |
|||
"multipleOf": { |
|||
"type": "number", |
|||
"exclusiveMinimum": 0 |
|||
}, |
|||
"maximum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMaximum": { |
|||
"type": "number" |
|||
}, |
|||
"minimum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMinimum": { |
|||
"type": "number" |
|||
}, |
|||
"maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"pattern": { |
|||
"type": "string", |
|||
"format": "regex" |
|||
}, |
|||
"additionalItems": { "$ref": "#" }, |
|||
"items": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/schemaArray" } |
|||
], |
|||
"default": {} |
|||
}, |
|||
"maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"uniqueItems": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"contains": { "$ref": "#" }, |
|||
"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"required": { "$ref": "#/definitions/stringArray" }, |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"definitions": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"properties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"patternProperties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"dependencies": { |
|||
"type": "object", |
|||
"additionalProperties": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/stringArray" } |
|||
] |
|||
} |
|||
}, |
|||
"propertyNames": { "$ref": "#" }, |
|||
"const": {}, |
|||
"enum": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
}, |
|||
"type": { |
|||
"anyOf": [ |
|||
{ "$ref": "#/definitions/simpleTypes" }, |
|||
{ |
|||
"type": "array", |
|||
"items": { "$ref": "#/definitions/simpleTypes" }, |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
} |
|||
] |
|||
}, |
|||
"format": { "type": "string" }, |
|||
"allOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"anyOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"oneOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"not": { "$ref": "#" } |
|||
}, |
|||
"default": {} |
|||
} |
|||
@ -1,168 +0,0 @@ |
|||
{ |
|||
"$schema": "http://json-schema.org/draft-07/schema#", |
|||
"$id": "http://json-schema.org/draft-07/schema#", |
|||
"title": "Core schema meta-schema", |
|||
"definitions": { |
|||
"schemaArray": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"items": { "$ref": "#" } |
|||
}, |
|||
"nonNegativeInteger": { |
|||
"type": "integer", |
|||
"minimum": 0 |
|||
}, |
|||
"nonNegativeIntegerDefault0": { |
|||
"allOf": [ |
|||
{ "$ref": "#/definitions/nonNegativeInteger" }, |
|||
{ "default": 0 } |
|||
] |
|||
}, |
|||
"simpleTypes": { |
|||
"enum": [ |
|||
"array", |
|||
"boolean", |
|||
"integer", |
|||
"null", |
|||
"number", |
|||
"object", |
|||
"string" |
|||
] |
|||
}, |
|||
"stringArray": { |
|||
"type": "array", |
|||
"items": { "type": "string" }, |
|||
"uniqueItems": true, |
|||
"default": [] |
|||
} |
|||
}, |
|||
"type": ["object", "boolean"], |
|||
"properties": { |
|||
"$id": { |
|||
"type": "string", |
|||
"format": "uri-reference" |
|||
}, |
|||
"$schema": { |
|||
"type": "string", |
|||
"format": "uri" |
|||
}, |
|||
"$ref": { |
|||
"type": "string", |
|||
"format": "uri-reference" |
|||
}, |
|||
"$comment": { |
|||
"type": "string" |
|||
}, |
|||
"title": { |
|||
"type": "string" |
|||
}, |
|||
"description": { |
|||
"type": "string" |
|||
}, |
|||
"default": true, |
|||
"readOnly": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"examples": { |
|||
"type": "array", |
|||
"items": true |
|||
}, |
|||
"multipleOf": { |
|||
"type": "number", |
|||
"exclusiveMinimum": 0 |
|||
}, |
|||
"maximum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMaximum": { |
|||
"type": "number" |
|||
}, |
|||
"minimum": { |
|||
"type": "number" |
|||
}, |
|||
"exclusiveMinimum": { |
|||
"type": "number" |
|||
}, |
|||
"maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"pattern": { |
|||
"type": "string", |
|||
"format": "regex" |
|||
}, |
|||
"additionalItems": { "$ref": "#" }, |
|||
"items": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/schemaArray" } |
|||
], |
|||
"default": true |
|||
}, |
|||
"maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"uniqueItems": { |
|||
"type": "boolean", |
|||
"default": false |
|||
}, |
|||
"contains": { "$ref": "#" }, |
|||
"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, |
|||
"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|||
"required": { "$ref": "#/definitions/stringArray" }, |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"definitions": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"properties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"default": {} |
|||
}, |
|||
"patternProperties": { |
|||
"type": "object", |
|||
"additionalProperties": { "$ref": "#" }, |
|||
"propertyNames": { "format": "regex" }, |
|||
"default": {} |
|||
}, |
|||
"dependencies": { |
|||
"type": "object", |
|||
"additionalProperties": { |
|||
"anyOf": [ |
|||
{ "$ref": "#" }, |
|||
{ "$ref": "#/definitions/stringArray" } |
|||
] |
|||
} |
|||
}, |
|||
"propertyNames": { "$ref": "#" }, |
|||
"const": true, |
|||
"enum": { |
|||
"type": "array", |
|||
"items": true, |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
}, |
|||
"type": { |
|||
"anyOf": [ |
|||
{ "$ref": "#/definitions/simpleTypes" }, |
|||
{ |
|||
"type": "array", |
|||
"items": { "$ref": "#/definitions/simpleTypes" }, |
|||
"minItems": 1, |
|||
"uniqueItems": true |
|||
} |
|||
] |
|||
}, |
|||
"format": { "type": "string" }, |
|||
"contentMediaType": { "type": "string" }, |
|||
"contentEncoding": { "type": "string" }, |
|||
"if": {"$ref": "#"}, |
|||
"then": {"$ref": "#"}, |
|||
"else": {"$ref": "#"}, |
|||
"allOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"anyOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"oneOf": { "$ref": "#/definitions/schemaArray" }, |
|||
"not": { "$ref": "#" } |
|||
}, |
|||
"default": true |
|||
} |
|||
@ -1,94 +0,0 @@ |
|||
{ |
|||
"$schema": "http://json-schema.org/draft-07/schema#", |
|||
"$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#", |
|||
"title": "Meta-schema for the security assessment of JSON Schemas", |
|||
"description": "If a JSON Schema fails validation against this meta-schema, it may be unsafe to validate untrusted data", |
|||
"definitions": { |
|||
"schemaArray": { |
|||
"type": "array", |
|||
"minItems": 1, |
|||
"items": {"$ref": "#"} |
|||
} |
|||
}, |
|||
"dependencies": { |
|||
"patternProperties": { |
|||
"description": "prevent slow validation of large property names", |
|||
"required": ["propertyNames"], |
|||
"properties": { |
|||
"propertyNames": { |
|||
"required": ["maxLength"] |
|||
} |
|||
} |
|||
}, |
|||
"uniqueItems": { |
|||
"description": "prevent slow validation of large non-scalar arrays", |
|||
"if": { |
|||
"properties": { |
|||
"uniqueItems": {"const": true}, |
|||
"items": { |
|||
"properties": { |
|||
"type": { |
|||
"anyOf": [ |
|||
{ |
|||
"enum": ["object", "array"] |
|||
}, |
|||
{ |
|||
"type": "array", |
|||
"contains": {"enum": ["object", "array"]} |
|||
} |
|||
] |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}, |
|||
"then": { |
|||
"required": ["maxItems"] |
|||
} |
|||
}, |
|||
"pattern": { |
|||
"description": "prevent slow pattern matching of large strings", |
|||
"required": ["maxLength"] |
|||
}, |
|||
"format": { |
|||
"description": "prevent slow format validation of large strings", |
|||
"required": ["maxLength"] |
|||
} |
|||
}, |
|||
"properties": { |
|||
"additionalItems": {"$ref": "#"}, |
|||
"additionalProperties": {"$ref": "#"}, |
|||
"dependencies": { |
|||
"additionalProperties": { |
|||
"anyOf": [ |
|||
{"type": "array"}, |
|||
{"$ref": "#"} |
|||
] |
|||
} |
|||
}, |
|||
"items": { |
|||
"anyOf": [ |
|||
{"$ref": "#"}, |
|||
{"$ref": "#/definitions/schemaArray"} |
|||
] |
|||
}, |
|||
"definitions": { |
|||
"additionalProperties": {"$ref": "#"} |
|||
}, |
|||
"patternProperties": { |
|||
"additionalProperties": {"$ref": "#"} |
|||
}, |
|||
"properties": { |
|||
"additionalProperties": {"$ref": "#"} |
|||
}, |
|||
"if": {"$ref": "#"}, |
|||
"then": {"$ref": "#"}, |
|||
"else": {"$ref": "#"}, |
|||
"allOf": {"$ref": "#/definitions/schemaArray"}, |
|||
"anyOf": {"$ref": "#/definitions/schemaArray"}, |
|||
"oneOf": {"$ref": "#/definitions/schemaArray"}, |
|||
"not": {"$ref": "#"}, |
|||
"contains": {"$ref": "#"}, |
|||
"propertyNames": {"$ref": "#"} |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue