basant307/AI_Governance_Project

1'use strict';2 3var 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 13module.exports = Ajv;14 15Ajv.prototype.validate = validate;16Ajv.prototype.compile = compile;17Ajv.prototype.addSchema = addSchema;18Ajv.prototype.addMetaSchema = addMetaSchema;19Ajv.prototype.validateSchema = validateSchema;20Ajv.prototype.getSchema = getSchema;21Ajv.prototype.removeSchema = removeSchema;22Ajv.prototype.addFormat = addFormat;23Ajv.prototype.errorsText = errorsText;24 25Ajv.prototype._addSchema = _addSchema;26Ajv.prototype._compile = _compile;27 28Ajv.prototype.compileAsync = require('./compile/async');29var customKeyword = require('./keyword');30Ajv.prototype.addKeyword = customKeyword.add;31Ajv.prototype.getKeyword = customKeyword.get;32Ajv.prototype.removeKeyword = customKeyword.remove;33Ajv.prototype.validateKeyword = customKeyword.validate;34 35var errorClasses = require('./compile/error_classes');36Ajv.ValidationError = errorClasses.Validation;37Ajv.MissingRefError = errorClasses.MissingRef;38Ajv.$dataMetaSchema = $dataMetaSchema;39 40var META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema';41 42var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ];43var META_SUPPORT_DATA = ['/properties'];44 45/**46 * Creates validator instance.47 * Usage: `Ajv(opts)`48 * @param {Object} opts optional options49 * @return {Object} ajv instance50 */51function 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 schema83 * 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   Ajv85 * @param  {String|Object} schemaKeyRef key, ref or schema object86 * @param  {Any} data to be validated87 * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).88 */89function 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   Ajv108 * @param  {Object} schema schema object109 * @param  {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.110 * @return {Function} validating function111 */112function 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   Ajv121 * @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 chaining126 */127function 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 schemas144 * options in META_IGNORE_OPTIONS are alway set to false145 * @this   Ajv146 * @param {Object} schema schema object147 * @param {String} key optional schema key148 * @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema149 * @return {Ajv} this for method chaining150 */151function addMetaSchema(schema, key, skipValidation) {152  this.addSchema(schema, key, skipValidation, true);153  return this;154}155 156 157/**158 * Validate schema159 * @this   Ajv160 * @param {Object} schema schema to validate161 * @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid162 * @return {Boolean} true if schema is valid163 */164function 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 184function defaultMeta(self) {185  var meta = self._opts.meta;186  self._opts.defaultMeta = typeof meta == 'object'187                            ? self._getId(meta) || meta188                            : self.getSchema(META_SCHEMA_ID)189                              ? META_SCHEMA_ID190                              : undefined;191  return self._opts.defaultMeta;192}193 194 195/**196 * Get compiled schema from the instance by `key` or `ref`.197 * @this   Ajv198 * @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 */201function 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 211function _getSchemaFragment(self, ref) {212  var res = resolve.schema.call(self, { schema: {} }, ref);213  if (res) {214    var schema = res.schema215      , root = res.root216      , 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: v225    });226    return v;227  }228}229 230 231function _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   Ajv243 * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object244 * @return {Ajv} this for method chaining245 */246function 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 279function _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 */291function _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: meta317  });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 */329function _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 376function 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 */385function _getId(schema) {386  if (schema.$id) this.logger.warn('schema $id ignored', schema.$id);387  return schema.id;388}389 390/* @this   Ajv */391function _get$Id(schema) {392  if (schema.id) this.logger.warn('schema id ignored', schema.id);393  return schema.$id;394}395 396 397function _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 string406 * @this   Ajv407 * @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 descriptions410 */411function 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 format429 * @this   Ajv430 * @param {String} name format name431 * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)432 * @return {Ajv} this for method chaining433 */434function addFormat(name, format) {435  if (typeof format == 'string') format = new RegExp(format);436  this._formats[name] = format;437  return this;438}439 440 441function 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 455function 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 463function 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 471function 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 479function 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 485function 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 493function 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 506function noop() {}507