fix: merged schemas reference resolving

Author: ivan-tymoshenko

index.js

@@ -40,12 +40,47 @@ function isValidSchema (schema, name) {
   }
 }
 
-function mergeLocation (location, key) {
-  return {
-    schema: location.schema[key],
-    schemaId: location.schemaId,
-    jsonPointer: location.jsonPointer + '/' + key,
-    isValidated: location.isValidated
+class Location {
+  constructor (schema, schemaId, jsonPointer = '#', isValidated = false) {
+    this.schema = schema
+    this.schemaId = schemaId
+    this.jsonPointer = jsonPointer
+    this.isValidated = isValidated
+
+    this.isMerged = false
+    this.mergedSchemaId = null
+    this.mergedJsonPointer = null
+  }
+
+  getPropertyLocation(propertyName) {
+    const propertyLocation = new Location(
+      this.schema[propertyName],
+      this.schemaId,
+      this.jsonPointer + '/' + propertyName,
+      this.isValidated
+    )
+
+    if (this.isMerged) {
+      propertyLocation.addMergedSchema(
+        this.mergedSchemaId,
+        this.mergedJsonPointer + '/' + propertyName
+      )
+    }
+
+    return propertyLocation
+  }
+
+  getSchemaRef () {
+    if (this.isMerged) {
+      return this.mergedSchemaId + this.mergedJsonPointer
+    }
+    return this.schemaId + this.jsonPointer
+  }
+
+  addMergedSchema (schemaId, jsonPointer = '#') {
+    this.isMerged = true
+    this.mergedSchemaId = schemaId
+    this.mergedJsonPointer = jsonPointer
   }
 }
 
@@ -68,11 +103,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 +161,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 = `
@@ -248,9 +284,9 @@ function addPatternProperties (location) {
         if (properties[keys[i]]) continue
   `
 
-  const patternPropertiesLocation = mergeLocation(location, 'patternProperties')
+  const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
   Object.keys(pp).forEach((regex) => {
-    let ppLocation = mergeLocation(patternPropertiesLocation, regex)
+    let ppLocation = patternPropertiesLocation.getPropertyLocation(regex)
     if (pp[regex].$ref) {
       ppLocation = resolveRef(ppLocation, pp[regex].$ref)
       pp[regex] = ppLocation.schema
@@ -296,7 +332,7 @@ function additionalProperty (location) {
     return code
   }
 
-  let apLocation = mergeLocation(location, 'additionalProperties')
+  let apLocation = location.getPropertyLocation('additionalProperties')
   if (apLocation.schema.$ref) {
     apLocation = resolveRef(apLocation, apLocation.schema.$ref)
   }
@@ -333,9 +369,12 @@ function buildCode (location) {
 
   let code = ''
 
-  const propertiesLocation = mergeLocation(location, 'properties')
+  if (!(location instanceof Location)) {
+    console.log(location)
+  }
+  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)
     }
@@ -382,13 +421,13 @@ function buildCode (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
     }
 
@@ -477,8 +516,9 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
 
   mergedSchema.$id = `merged_${randomUUID()}`
   refResolver.addSchema(mergedSchema)
-  location.schemaId = mergedSchema.$id
-  location.jsonPointer = '#'
+
+  location.schema = mergedSchema
+  location.addMergedSchema(mergedSchema.$id)
 }
 
 function buildInnerObject (location) {
@@ -494,7 +534,11 @@ function buildInnerObject (location) {
 
 function addIfThenElse (location, input) {
   location.isValidated = true
-  validatorSchemasIds.add(location.schemaId)
+  if (location.isMerged) {
+    validatorSchemasIds.add(location.mergedSchemaId)
+  } else {
+    validatorSchemasIds.add(location.schemaId)
+  }
 
   const schema = merge({}, location.schema)
   const thenSchema = schema.then
@@ -504,13 +548,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 `
@@ -565,7 +609,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) {
@@ -617,7 +661,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}]`)}) {
@@ -713,11 +757,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 += `
@@ -862,10 +906,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
@@ -874,14 +916,18 @@ function buildValue (location, input) {
 
   if (type === undefined && (schema.anyOf || schema.oneOf)) {
     location.isValidated = true
-    validatorSchemasIds.add(location.schemaId)
+    if (location.isMerged) {
+      validatorSchemasIds.add(location.mergedSchemaId)
+    } else {
+      validatorSchemasIds.add(location.schemaId)
+    }
 
     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}))

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))
+})