| '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; |
| } |