fix: track schema dependecies (#556)

Author: ivan-tymoshenko

index.js

@@ -56,11 +56,7 @@ function resolveRef (location, ref) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
-  if (location.isValidated) {
-    validatorSchemasIds.add(schemaId)
-  }
-
-  const newLocation = new Location(schema, schemaId, jsonPointer, location.isValidated)
+  const newLocation = new Location(schema, schemaId, jsonPointer)
   if (schema.$ref !== undefined) {
     return resolveRef(newLocation, schema.$ref)
   }
@@ -137,6 +133,11 @@ function build (schema, options) {
   for (const schemaId of validatorSchemasIds) {
     const schema = refResolver.getSchema(schemaId)
     validator.addSchema(schema, schemaId)
+
+    const dependencies = refResolver.getSchemaDependencies(schemaId)
+    for (const [schemaId, schema] of Object.entries(dependencies)) {
+      validator.addSchema(schema, schemaId)
+    }
   }
 
   const dependenciesName = ['validator', 'serializer', contextFunctionCode]
@@ -454,7 +455,6 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
 }
 
 function addIfThenElse (location, input) {
-  location.isValidated = true
   validatorSchemasIds.add(location.getSchemaId())
 
   const schema = merge({}, location.schema)
@@ -840,7 +840,6 @@ function buildValue (location, input) {
   let code = ''
 
   if (type === undefined && (schema.anyOf || schema.oneOf)) {
-    location.isValidated = true
     validatorSchemasIds.add(location.getSchemaId())
 
     const type = schema.anyOf ? 'anyOf' : 'oneOf'

lib/location.js

@@ -1,20 +1,18 @@
 'use strict'
 
 class Location {
-  constructor (schema, schemaId, jsonPointer = '#', isValidated = false) {
+  constructor (schema, schemaId, jsonPointer = '#') {
     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
+      this.jsonPointer + '/' + propertyName
     )
 
     if (this.mergedSchemaId !== null) {

lib/ref-resolver.js

@@ -28,14 +28,26 @@ class RefResolver {
     return getDataByJSONPointer(schema.schema, jsonPointer)
   }
 
+  getSchemaDependencies (schemaId, dependencies = {}) {
+    const schema = this.schemas[schemaId]
+
+    for (const dependencySchemaId of schema.dependencies) {
+      if (dependencies[dependencySchemaId] !== undefined) continue
+      dependencies[dependencySchemaId] = this.getSchema(dependencySchemaId)
+      this.getSchemaDependencies(dependencySchemaId, dependencies)
+    }
+
+    return dependencies
+  }
+
   insertSchemaBySchemaId (schema, schemaId) {
     if (
       this.schemas[schemaId] !== undefined &&
       !deepEqual(schema, this.schemas[schemaId].schema)
     ) {
       throw new Error(`There is already another schema with id ${schemaId}`)
     }
-    this.schemas[schemaId] = { schema, anchors: {} }
+    this.schemas[schemaId] = { schema, anchors: {}, dependencies: [] }
   }
 
   insertSchemaByAnchor (schema, schemaId, anchor) {
@@ -60,6 +72,14 @@ class RefResolver {
       }
     }
 
+    const ref = schema.$ref
+    if (ref !== undefined && typeof ref === 'string') {
+      if (ref.charAt(0) !== '#') {
+        const dependencySchemaId = ref.split('#')[0]
+        this.schemas[rootSchemaId].dependencies.push(dependencySchemaId)
+      }
+    }
+
     for (const key in schema) {
       if (typeof schema[key] === 'object' && schema[key] !== null) {
         this.insertSchemaSubschemas(schema[key], rootSchemaId)

test/anyof.test.js

@@ -616,3 +616,31 @@ test('anyOf with a nested external schema', (t) => {
   const stringify = build(schema, { schema: externalSchemas })
   t.equal(stringify('foo'), '"foo"')
 })
+
+test('object with ref and validated properties', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    RefSchema: {
+      $id: 'RefSchema',
+      type: 'string'
+    }
+  }
+
+  const schema = {
+    $id: 'root',
+    type: 'object',
+    properties: {
+      id: {
+        anyOf: [
+          { type: 'string' },
+          { type: 'number' }
+        ]
+      },
+      reference: { $ref: 'RefSchema' }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchemas })
+  t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
+})