twitst4tz

twitter statistics web application
Log | Files | Refs | README | LICENSE

ajv.js (15837B)

      1 'use strict';
      2 
      3 var compileSchema = require('./compile')
      4   , resolve = require('./compile/resolve')
      5   , Cache = require('./cache')
      6   , SchemaObject = require('./compile/schema_obj')
      7   , stableStringify = require('fast-json-stable-stringify')
      8   , formats = require('./compile/formats')
      9   , rules = require('./compile/rules')
     10   , $dataMetaSchema = require('./data')
     11   , util = require('./compile/util');
     12 
     13 module.exports = Ajv;
     14 
     15 Ajv.prototype.validate = validate;
     16 Ajv.prototype.compile = compile;
     17 Ajv.prototype.addSchema = addSchema;
     18 Ajv.prototype.addMetaSchema = addMetaSchema;
     19 Ajv.prototype.validateSchema = validateSchema;
     20 Ajv.prototype.getSchema = getSchema;
     21 Ajv.prototype.removeSchema = removeSchema;
     22 Ajv.prototype.addFormat = addFormat;
     23 Ajv.prototype.errorsText = errorsText;
     24 
     25 Ajv.prototype._addSchema = _addSchema;
     26 Ajv.prototype._compile = _compile;
     27 
     28 Ajv.prototype.compileAsync = require('./compile/async');
     29 var customKeyword = require('./keyword');
     30 Ajv.prototype.addKeyword = customKeyword.add;
     31 Ajv.prototype.getKeyword = customKeyword.get;
     32 Ajv.prototype.removeKeyword = customKeyword.remove;
     33 Ajv.prototype.validateKeyword = customKeyword.validate;
     34 
     35 var errorClasses = require('./compile/error_classes');
     36 Ajv.ValidationError = errorClasses.Validation;
     37 Ajv.MissingRefError = errorClasses.MissingRef;
     38 Ajv.$dataMetaSchema = $dataMetaSchema;
     39 
     40 var META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema';
     41 
     42 var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ];
     43 var META_SUPPORT_DATA = ['/properties'];
     44 
     45 /**
     46  * Creates validator instance.
     47  * Usage: `Ajv(opts)`
     48  * @param {Object} opts optional options
     49  * @return {Object} ajv instance
     50  */
     51 function Ajv(opts) {
     52   if (!(this instanceof Ajv)) return new Ajv(opts);
     53   opts = this._opts = util.copy(opts) || {};
     54   setLogger(this);
     55   this._schemas = {};
     56   this._refs = {};
     57   this._fragments = {};
     58   this._formats = formats(opts.format);
     59 
     60   this._cache = opts.cache || new Cache;
     61   this._loadingSchemas = {};
     62   this._compilations = [];
     63   this.RULES = rules();
     64   this._getId = chooseGetId(opts);
     65 
     66   opts.loopRequired = opts.loopRequired || Infinity;
     67   if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true;
     68   if (opts.serialize === undefined) opts.serialize = stableStringify;
     69   this._metaOpts = getMetaSchemaOptions(this);
     70 
     71   if (opts.formats) addInitialFormats(this);
     72   if (opts.keywords) addInitialKeywords(this);
     73   addDefaultMetaSchema(this);
     74   if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta);
     75   if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}});
     76   addInitialSchemas(this);
     77 }
     78 
     79 
     80 
     81 /**
     82  * Validate data using schema
     83  * 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.
     84  * @this   Ajv
     85  * @param  {String|Object} schemaKeyRef key, ref or schema object
     86  * @param  {Any} data to be validated
     87  * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).
     88  */
     89 function validate(schemaKeyRef, data) {
     90   var v;
     91   if (typeof schemaKeyRef == 'string') {
     92     v = this.getSchema(schemaKeyRef);
     93     if (!v) throw new Error('no schema with key or ref "' + schemaKeyRef + '"');
     94   } else {
     95     var schemaObj = this._addSchema(schemaKeyRef);
     96     v = schemaObj.validate || this._compile(schemaObj);
     97   }
     98 
     99   var valid = v(data);
    100   if (v.$async !== true) this.errors = v.errors;
    101   return valid;
    102 }
    103 
    104 
    105 /**
    106  * Create validating function for passed schema.
    107  * @this   Ajv
    108  * @param  {Object} schema schema object
    109  * @param  {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.
    110  * @return {Function} validating function
    111  */
    112 function compile(schema, _meta) {
    113   var schemaObj = this._addSchema(schema, undefined, _meta);
    114   return schemaObj.validate || this._compile(schemaObj);
    115 }
    116 
    117 
    118 /**
    119  * Adds schema to the instance.
    120  * @this   Ajv
    121  * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.
    122  * @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`.
    123  * @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead.
    124  * @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
    125  * @return {Ajv} this for method chaining
    126  */
    127 function addSchema(schema, key, _skipValidation, _meta) {
    128   if (Array.isArray(schema)){
    129     for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta);
    130     return this;
    131   }
    132   var id = this._getId(schema);
    133   if (id !== undefined && typeof id != 'string')
    134     throw new Error('schema id must be string');
    135   key = resolve.normalizeId(key || id);
    136   checkUnique(this, key);
    137   this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);
    138   return this;
    139 }
    140 
    141 
    142 /**
    143  * Add schema that will be used to validate other schemas
    144  * options in META_IGNORE_OPTIONS are alway set to false
    145  * @this   Ajv
    146  * @param {Object} schema schema object
    147  * @param {String} key optional schema key
    148  * @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema
    149  * @return {Ajv} this for method chaining
    150  */
    151 function addMetaSchema(schema, key, skipValidation) {
    152   this.addSchema(schema, key, skipValidation, true);
    153   return this;
    154 }
    155 
    156 
    157 /**
    158  * Validate schema
    159  * @this   Ajv
    160  * @param {Object} schema schema to validate
    161  * @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid
    162  * @return {Boolean} true if schema is valid
    163  */
    164 function validateSchema(schema, throwOrLogError) {
    165   var $schema = schema.$schema;
    166   if ($schema !== undefined && typeof $schema != 'string')
    167     throw new Error('$schema must be a string');
    168   $schema = $schema || this._opts.defaultMeta || defaultMeta(this);
    169   if (!$schema) {
    170     this.logger.warn('meta-schema not available');
    171     this.errors = null;
    172     return true;
    173   }
    174   var valid = this.validate($schema, schema);
    175   if (!valid && throwOrLogError) {
    176     var message = 'schema is invalid: ' + this.errorsText();
    177     if (this._opts.validateSchema == 'log') this.logger.error(message);
    178     else throw new Error(message);
    179   }
    180   return valid;
    181 }
    182 
    183 
    184 function defaultMeta(self) {
    185   var meta = self._opts.meta;
    186   self._opts.defaultMeta = typeof meta == 'object'
    187                             ? self._getId(meta) || meta
    188                             : self.getSchema(META_SCHEMA_ID)
    189                               ? META_SCHEMA_ID
    190                               : undefined;
    191   return self._opts.defaultMeta;
    192 }
    193 
    194 
    195 /**
    196  * Get compiled schema from the instance by `key` or `ref`.
    197  * @this   Ajv
    198  * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).
    199  * @return {Function} schema validating function (with property `schema`).
    200  */
    201 function getSchema(keyRef) {
    202   var schemaObj = _getSchemaObj(this, keyRef);
    203   switch (typeof schemaObj) {
    204     case 'object': return schemaObj.validate || this._compile(schemaObj);
    205     case 'string': return this.getSchema(schemaObj);
    206     case 'undefined': return _getSchemaFragment(this, keyRef);
    207   }
    208 }
    209 
    210 
    211 function _getSchemaFragment(self, ref) {
    212   var res = resolve.schema.call(self, { schema: {} }, ref);
    213   if (res) {
    214     var schema = res.schema
    215       , root = res.root
    216       , baseId = res.baseId;
    217     var v = compileSchema.call(self, schema, root, undefined, baseId);
    218     self._fragments[ref] = new SchemaObject({
    219       ref: ref,
    220       fragment: true,
    221       schema: schema,
    222       root: root,
    223       baseId: baseId,
    224       validate: v
    225     });
    226     return v;
    227   }
    228 }
    229 
    230 
    231 function _getSchemaObj(self, keyRef) {
    232   keyRef = resolve.normalizeId(keyRef);
    233   return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];
    234 }
    235 
    236 
    237 /**
    238  * Remove cached schema(s).
    239  * If no parameter is passed all schemas but meta-schemas are removed.
    240  * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
    241  * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
    242  * @this   Ajv
    243  * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object
    244  * @return {Ajv} this for method chaining
    245  */
    246 function removeSchema(schemaKeyRef) {
    247   if (schemaKeyRef instanceof RegExp) {
    248     _removeAllSchemas(this, this._schemas, schemaKeyRef);
    249     _removeAllSchemas(this, this._refs, schemaKeyRef);
    250     return this;
    251   }
    252   switch (typeof schemaKeyRef) {
    253     case 'undefined':
    254       _removeAllSchemas(this, this._schemas);
    255       _removeAllSchemas(this, this._refs);
    256       this._cache.clear();
    257       return this;
    258     case 'string':
    259       var schemaObj = _getSchemaObj(this, schemaKeyRef);
    260       if (schemaObj) this._cache.del(schemaObj.cacheKey);
    261       delete this._schemas[schemaKeyRef];
    262       delete this._refs[schemaKeyRef];
    263       return this;
    264     case 'object':
    265       var serialize = this._opts.serialize;
    266       var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;
    267       this._cache.del(cacheKey);
    268       var id = this._getId(schemaKeyRef);
    269       if (id) {
    270         id = resolve.normalizeId(id);
    271         delete this._schemas[id];
    272         delete this._refs[id];
    273       }
    274   }
    275   return this;
    276 }
    277 
    278 
    279 function _removeAllSchemas(self, schemas, regex) {
    280   for (var keyRef in schemas) {
    281     var schemaObj = schemas[keyRef];
    282     if (!schemaObj.meta && (!regex || regex.test(keyRef))) {
    283       self._cache.del(schemaObj.cacheKey);
    284       delete schemas[keyRef];
    285     }
    286   }
    287 }
    288 
    289 
    290 /* @this   Ajv */
    291 function _addSchema(schema, skipValidation, meta, shouldAddSchema) {
    292   if (typeof schema != 'object' && typeof schema != 'boolean')
    293     throw new Error('schema should be object or boolean');
    294   var serialize = this._opts.serialize;
    295   var cacheKey = serialize ? serialize(schema) : schema;
    296   var cached = this._cache.get(cacheKey);
    297   if (cached) return cached;
    298 
    299   shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
    300 
    301   var id = resolve.normalizeId(this._getId(schema));
    302   if (id && shouldAddSchema) checkUnique(this, id);
    303 
    304   var willValidate = this._opts.validateSchema !== false && !skipValidation;
    305   var recursiveMeta;
    306   if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema)))
    307     this.validateSchema(schema, true);
    308 
    309   var localRefs = resolve.ids.call(this, schema);
    310 
    311   var schemaObj = new SchemaObject({
    312     id: id,
    313     schema: schema,
    314     localRefs: localRefs,
    315     cacheKey: cacheKey,
    316     meta: meta
    317   });
    318 
    319   if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj;
    320   this._cache.put(cacheKey, schemaObj);
    321 
    322   if (willValidate && recursiveMeta) this.validateSchema(schema, true);
    323 
    324   return schemaObj;
    325 }
    326 
    327 
    328 /* @this   Ajv */
    329 function _compile(schemaObj, root) {
    330   if (schemaObj.compiling) {
    331     schemaObj.validate = callValidate;
    332     callValidate.schema = schemaObj.schema;
    333     callValidate.errors = null;
    334     callValidate.root = root ? root : callValidate;
    335     if (schemaObj.schema.$async === true)
    336       callValidate.$async = true;
    337     return callValidate;
    338   }
    339   schemaObj.compiling = true;
    340 
    341   var currentOpts;
    342   if (schemaObj.meta) {
    343     currentOpts = this._opts;
    344     this._opts = this._metaOpts;
    345   }
    346 
    347   var v;
    348   try { v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs); }
    349   catch(e) {
    350     delete schemaObj.validate;
    351     throw e;
    352   }
    353   finally {
    354     schemaObj.compiling = false;
    355     if (schemaObj.meta) this._opts = currentOpts;
    356   }
    357 
    358   schemaObj.validate = v;
    359   schemaObj.refs = v.refs;
    360   schemaObj.refVal = v.refVal;
    361   schemaObj.root = v.root;
    362   return v;
    363 
    364 
    365   /* @this   {*} - custom context, see passContext option */
    366   function callValidate() {
    367     /* jshint validthis: true */
    368     var _validate = schemaObj.validate;
    369     var result = _validate.apply(this, arguments);
    370     callValidate.errors = _validate.errors;
    371     return result;
    372   }
    373 }
    374 
    375 
    376 function chooseGetId(opts) {
    377   switch (opts.schemaId) {
    378     case 'auto': return _get$IdOrId;
    379     case 'id': return _getId;
    380     default: return _get$Id;
    381   }
    382 }
    383 
    384 /* @this   Ajv */
    385 function _getId(schema) {
    386   if (schema.$id) this.logger.warn('schema $id ignored', schema.$id);
    387   return schema.id;
    388 }
    389 
    390 /* @this   Ajv */
    391 function _get$Id(schema) {
    392   if (schema.id) this.logger.warn('schema id ignored', schema.id);
    393   return schema.$id;
    394 }
    395 
    396 
    397 function _get$IdOrId(schema) {
    398   if (schema.$id && schema.id && schema.$id != schema.id)
    399     throw new Error('schema $id is different from id');
    400   return schema.$id || schema.id;
    401 }
    402 
    403 
    404 /**
    405  * Convert array of error message objects to string
    406  * @this   Ajv
    407  * @param  {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used.
    408  * @param  {Object} options optional options with properties `separator` and `dataVar`.
    409  * @return {String} human readable string with all errors descriptions
    410  */
    411 function errorsText(errors, options) {
    412   errors = errors || this.errors;
    413   if (!errors) return 'No errors';
    414   options = options || {};
    415   var separator = options.separator === undefined ? ', ' : options.separator;
    416   var dataVar = options.dataVar === undefined ? 'data' : options.dataVar;
    417 
    418   var text = '';
    419   for (var i=0; i<errors.length; i++) {
    420     var e = errors[i];
    421     if (e) text += dataVar + e.dataPath + ' ' + e.message + separator;
    422   }
    423   return text.slice(0, -separator.length);
    424 }
    425 
    426 
    427 /**
    428  * Add custom format
    429  * @this   Ajv
    430  * @param {String} name format name
    431  * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)
    432  * @return {Ajv} this for method chaining
    433  */
    434 function addFormat(name, format) {
    435   if (typeof format == 'string') format = new RegExp(format);
    436   this._formats[name] = format;
    437   return this;
    438 }
    439 
    440 
    441 function addDefaultMetaSchema(self) {
    442   var $dataSchema;
    443   if (self._opts.$data) {
    444     $dataSchema = require('./refs/data.json');
    445     self.addMetaSchema($dataSchema, $dataSchema.$id, true);
    446   }
    447   if (self._opts.meta === false) return;
    448   var metaSchema = require('./refs/json-schema-draft-07.json');
    449   if (self._opts.$data) metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA);
    450   self.addMetaSchema(metaSchema, META_SCHEMA_ID, true);
    451   self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID;
    452 }
    453 
    454 
    455 function addInitialSchemas(self) {
    456   var optsSchemas = self._opts.schemas;
    457   if (!optsSchemas) return;
    458   if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas);
    459   else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key);
    460 }
    461 
    462 
    463 function addInitialFormats(self) {
    464   for (var name in self._opts.formats) {
    465     var format = self._opts.formats[name];
    466     self.addFormat(name, format);
    467   }
    468 }
    469 
    470 
    471 function addInitialKeywords(self) {
    472   for (var name in self._opts.keywords) {
    473     var keyword = self._opts.keywords[name];
    474     self.addKeyword(name, keyword);
    475   }
    476 }
    477 
    478 
    479 function checkUnique(self, id) {
    480   if (self._schemas[id] || self._refs[id])
    481     throw new Error('schema with key or id "' + id + '" already exists');
    482 }
    483 
    484 
    485 function getMetaSchemaOptions(self) {
    486   var metaOpts = util.copy(self._opts);
    487   for (var i=0; i<META_IGNORE_OPTIONS.length; i++)
    488     delete metaOpts[META_IGNORE_OPTIONS[i]];
    489   return metaOpts;
    490 }
    491 
    492 
    493 function setLogger(self) {
    494   var logger = self._opts.logger;
    495   if (logger === false) {
    496     self.logger = {log: noop, warn: noop, error: noop};
    497   } else {
    498     if (logger === undefined) logger = console;
    499     if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error))
    500       throw new Error('logger must implement log, warn and error methods');
    501     self.logger = logger;
    502   }
    503 }
    504 
    505 
    506 function noop() {}