fix: merged schemas reference resolving (#546)

* fix: merged schemas reference resolving

* refactor: move Location class to separate module

Author: ivan-tymoshenko

index.js

@@ -10,6 +10,7 @@ const validate = require('./lib/schema-validator')
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
 const RefResolver = require('./lib/ref-resolver')
+const Location = require('./lib/location')
 
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
@@ -40,22 +41,13 @@ function isValidSchema (schema, name) {
   }
 }
 
-function mergeLocation (location, key) {
-  return {
-    schema: location.schema[key],
-    schemaId: location.schemaId,
-    jsonPointer: location.jsonPointer + '/' + key,
-    isValidated: location.isValidated
-  }
-}
-
 function resolveRef (location, ref) {
   let hashIndex = ref.indexOf('#')
   if (hashIndex === -1) {
     hashIndex = ref.length
   }
 
-  const schemaId = ref.slice(0, hashIndex) || location.schemaId
+  const schemaId = ref.slice(0, hashIndex) || location.getOriginSchemaId()
   const jsonPointer = ref.slice(hashIndex) || '#'
 
   const schema = refResolver.getSchema(schemaId, jsonPointer)
@@ -68,11 +60,12 @@ function resolveRef (location, ref) {
     validatorSchemasIds.add(schemaId)
   }
 
+  const newLocation = new Location(schema, schemaId, jsonPointer, location.isValidated)
   if (schema.$ref !== undefined) {
-    return resolveRef({ schema, schemaId, jsonPointer }, schema.$ref)
+    return resolveRef(newLocation, schema.$ref)
   }
 
-  return { schema, schemaId, jsonPointer, isValidated: location.isValidated }
+  return newLocation
 }
 
 const contextFunctionsNamesBySchema = new Map()
@@ -125,7 +118,7 @@ function build (schema, options) {
     }
   }
 
-  const location = { schema, schemaId: rootSchemaId, jsonPointer: '#', isValidated: false }
+  const location = new Location(schema, rootSchemaId)
   const code = buildValue(location, 'input')
 
   const contextFunctionCode = `
@@ -253,17 +246,17 @@ function buildExtraObjectPropertiesSerializer (location) {
       ) continue
   `
 
-  const patternPropertiesLocation = mergeLocation(location, 'patternProperties')
+  const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
   const patternPropertiesSchema = patternPropertiesLocation.schema
 
   if (patternPropertiesSchema !== undefined) {
     for (const propertyKey in patternPropertiesSchema) {
-      const propertyLocation = mergeLocation(patternPropertiesLocation, propertyKey)
+      const propertyLocation = patternPropertiesLocation.getPropertyLocation(propertyKey)
 
       try {
         RegExp(propertyKey)
       } catch (err) {
-        const jsonPointer = propertyLocation.schema + propertyLocation.jsonPointer
+        const jsonPointer = propertyLocation.getSchemaRef()
         throw new Error(`${err.message}. Invalid pattern property regexp key ${propertyKey} at ${jsonPointer}`)
       }
 
@@ -278,7 +271,7 @@ function buildExtraObjectPropertiesSerializer (location) {
     }
   }
 
-  const additionalPropertiesLocation = mergeLocation(location, 'additionalProperties')
+  const additionalPropertiesLocation = location.getPropertyLocation('additionalProperties')
   const additionalPropertiesSchema = additionalPropertiesLocation.schema
 
   if (additionalPropertiesSchema !== undefined) {
@@ -288,7 +281,7 @@ function buildExtraObjectPropertiesSerializer (location) {
         json += serializer.asString(key) + ':' + JSON.stringify(value)
       `
     } else {
-      const propertyLocation = mergeLocation(location, 'additionalProperties')
+      const propertyLocation = location.getPropertyLocation('additionalProperties')
       code += `
         ${addComma}
         json += serializer.asString(key) + ':'
@@ -309,9 +302,9 @@ function buildInnerObject (location) {
 
   let code = ''
 
-  const propertiesLocation = mergeLocation(location, 'properties')
+  const propertiesLocation = location.getPropertyLocation('properties')
   Object.keys(schema.properties || {}).forEach((key) => {
-    let propertyLocation = mergeLocation(propertiesLocation, key)
+    let propertyLocation = propertiesLocation.getPropertyLocation(key)
     if (propertyLocation.schema.$ref) {
       propertyLocation = resolveRef(location, propertyLocation.schema.$ref)
     }
@@ -362,13 +355,13 @@ function buildInnerObject (location) {
 }
 
 function mergeAllOfSchema (location, schema, mergedSchema) {
-  const allOfLocation = mergeLocation(location, 'allOf')
+  const allOfLocation = location.getPropertyLocation('allOf')
 
   for (let i = 0; i < schema.allOf.length; i++) {
     let allOfSchema = schema.allOf[i]
 
     if (allOfSchema.$ref) {
-      const allOfSchemaLocation = mergeLocation(allOfLocation, i)
+      const allOfSchemaLocation = allOfLocation.getPropertyLocation(i)
       allOfSchema = resolveRef(allOfSchemaLocation, allOfSchema.$ref).schema
     }
 
@@ -457,13 +450,12 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
 
   mergedSchema.$id = `merged_${randomUUID()}`
   refResolver.addSchema(mergedSchema)
-  location.schemaId = mergedSchema.$id
-  location.jsonPointer = '#'
+  location.addMergedSchema(mergedSchema, mergedSchema.$id)
 }
 
 function addIfThenElse (location, input) {
   location.isValidated = true
-  validatorSchemasIds.add(location.schemaId)
+  validatorSchemasIds.add(location.getSchemaId())
 
   const schema = merge({}, location.schema)
   const thenSchema = schema.then
@@ -473,13 +465,13 @@ function addIfThenElse (location, input) {
   delete schema.then
   delete schema.else
 
-  const ifLocation = mergeLocation(location, 'if')
-  const ifSchemaRef = ifLocation.schemaId + ifLocation.jsonPointer
+  const ifLocation = location.getPropertyLocation('if')
+  const ifSchemaRef = ifLocation.getSchemaRef()
 
-  const thenLocation = mergeLocation(location, 'then')
+  const thenLocation = location.getPropertyLocation('then')
   thenLocation.schema = merge(schema, thenSchema)
 
-  const elseLocation = mergeLocation(location, 'else')
+  const elseLocation = location.getPropertyLocation('else')
   elseLocation.schema = merge(schema, elseSchema)
 
   return `
@@ -508,10 +500,14 @@ function buildObject (location) {
   const functionName = generateFuncName()
   contextFunctionsNamesBySchema.set(schema, functionName)
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
+
   let functionCode = `
     function ${functionName} (input) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
 
   functionCode += `
@@ -534,7 +530,7 @@ function buildObject (location) {
 function buildArray (location) {
   const schema = location.schema
 
-  let itemsLocation = mergeLocation(location, 'items')
+  let itemsLocation = location.getPropertyLocation('items')
   itemsLocation.schema = itemsLocation.schema || {}
 
   if (itemsLocation.schema.$ref) {
@@ -550,10 +546,14 @@ function buildArray (location) {
   const functionName = generateFuncName()
   contextFunctionsNamesBySchema.set(schema, functionName)
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
+
   let functionCode = `
     function ${functionName} (obj) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
 
   functionCode += `
@@ -586,7 +586,7 @@ function buildArray (location) {
   if (Array.isArray(itemsSchema)) {
     for (let i = 0; i < itemsSchema.length; i++) {
       const item = itemsSchema[i]
-      const tmpRes = buildValue(mergeLocation(itemsLocation, i), `obj[${i}]`)
+      const tmpRes = buildValue(itemsLocation.getPropertyLocation(i), `obj[${i}]`)
       functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
@@ -682,11 +682,11 @@ function buildMultiTypeSerializer (location, input) {
 
   let code = ''
 
-  const locationClone = clone(location)
   types.forEach((type, index) => {
+    location.schema = { ...location.schema, type }
+    const nestedResult = buildSingleTypeSerializer(location, input)
+
     const statement = index === 0 ? 'if' : 'else if'
-    locationClone.schema.type = type
-    const nestedResult = buildSingleTypeSerializer(locationClone, input)
     switch (type) {
       case 'null':
         code += `
@@ -831,10 +831,8 @@ function buildValue (location, input) {
   }
 
   if (schema.allOf) {
-    const mergedSchema = clone(schema)
-    mergeAllOfSchema(location, schema, mergedSchema)
-    schema = mergedSchema
-    location.schema = mergedSchema
+    mergeAllOfSchema(location, schema, clone(schema))
+    schema = location.schema
   }
 
   const type = schema.type
@@ -843,14 +841,14 @@ function buildValue (location, input) {
 
   if (type === undefined && (schema.anyOf || schema.oneOf)) {
     location.isValidated = true
-    validatorSchemasIds.add(location.schemaId)
+    validatorSchemasIds.add(location.getSchemaId())
 
     const type = schema.anyOf ? 'anyOf' : 'oneOf'
-    const anyOfLocation = mergeLocation(location, type)
+    const anyOfLocation = location.getPropertyLocation(type)
 
     for (let index = 0; index < location.schema[type].length; index++) {
-      const optionLocation = mergeLocation(anyOfLocation, index)
-      const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
+      const optionLocation = anyOfLocation.getPropertyLocation(index)
+      const schemaRef = optionLocation.getSchemaRef()
       const nestedResult = buildValue(optionLocation, input)
       code += `
         ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))

lib/location.js

@@ -0,0 +1,55 @@
+'use strict'
+
+class Location {
+  constructor (schema, schemaId, jsonPointer = '#', isValidated = false) {
+    this.schema = schema
+    this.schemaId = schemaId
+    this.jsonPointer = jsonPointer
+    this.isValidated = isValidated
+    this.mergedSchemaId = null
+  }
+
+  getPropertyLocation (propertyName) {
+    const propertyLocation = new Location(
+      this.schema[propertyName],
+      this.schemaId,
+      this.jsonPointer + '/' + propertyName,
+      this.isValidated
+    )
+
+    if (this.mergedSchemaId !== null) {
+      propertyLocation.addMergedSchema(
+        this.schema[propertyName],
+        this.mergedSchemaId,
+        this.jsonPointer + '/' + propertyName
+      )
+    }
+
+    return propertyLocation
+  }
+
+  // Use this method to get current schema location.
+  // Use it when you need to create reference to the current location.
+  getSchemaId () {
+    return this.mergedSchemaId || this.schemaId
+  }
+
+  // Use this method to get original schema id for resolving user schema $refs
+  // Don't join it with a JSON pointer to get the current location.
+  getOriginSchemaId () {
+    return this.schemaId
+  }
+
+  getSchemaRef () {
+    const schemaId = this.getSchemaId()
+    return schemaId + this.jsonPointer
+  }
+
+  addMergedSchema (mergedSchema, schemaId, jsonPointer = '#') {
+    this.schema = mergedSchema
+    this.mergedSchemaId = schemaId
+    this.jsonPointer = jsonPointer
+  }
+}
+
+module.exports = Location

test/allof.test.js

@@ -437,3 +437,48 @@ test('object with external $refs in allOf', (t) => {
   })
   t.equal(value, '{"id1":1,"id2":2}')
 })
+
+test('allof with local anchor reference', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    Test: {
+      $id: 'Test',
+      definitions: {
+        Problem: {
+          type: 'object',
+          properties: {
+            type: {
+              type: 'string'
+            }
+          }
+        },
+        ValidationFragment: {
+          type: 'string'
+        },
+        ValidationErrorProblem: {
+          type: 'object',
+          allOf: [
+            {
+              $ref: '#/definitions/Problem'
+            },
+            {
+              type: 'object',
+              properties: {
+                validation: {
+                  $ref: '#/definitions/ValidationFragment'
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const schema = { $ref: 'Test#/definitions/ValidationErrorProblem' }
+  const stringify = build(schema, { schema: externalSchemas })
+  const data = { type: 'foo', validation: 'bar' }
+
+  t.equal(stringify(data), JSON.stringify(data))
+})