fast-json-stringify 7.0.1 → 7.1.1

package/index.js

@@ -10,8 +10,31 @@ const Location = require('./lib/location')
 const validate = require('./lib/schema-validator')
 const mergeSchemas = require('./lib/merge-schemas')
 
-let largeArraySize = 2e4
-let largeArrayMechanism = 'default'
+const DEFAULT_MAX_DEPTH = 100
+const NAMED_FRAGMENT_REF = /^#[a-z_][-\w._]*$/i
+
+const singleSchemaKeywords = [
+  'additionalItems',
+  'additionalProperties',
+  'contains',
+  'else',
+  'if',
+  'not',
+  'propertyNames',
+  'then'
+]
+
+const arraySchemaKeywords = [
+  'allOf',
+  'anyOf',
+  'oneOf'
+]
+
+const objectSchemaKeywords = [
+  'definitions',
+  'patternProperties',
+  'properties'
+]
 
 const serializerFns = `
 const {
@@ -42,6 +65,113 @@ const validLargeArrayMechanisms = new Set([
 
 let schemaIdCounter = 0
 
+function getMaxDepth (options) {
+  const maxDepth = options.maxDepth === undefined ? DEFAULT_MAX_DEPTH : options.maxDepth
+  if (!Number.isInteger(maxDepth) || maxDepth < 0 || maxDepth > DEFAULT_MAX_DEPTH) {
+    throw new Error(`Unsupported max schema depth ${maxDepth}. Expected an integer between 0 and ${DEFAULT_MAX_DEPTH}.`)
+  }
+  return maxDepth
+}
+
+function schemaDepthError (maxDepth, name) {
+  const prefix = name ? `"${name}" ` : ''
+  return new Error(`${prefix}schema exceeds maximum depth of ${maxDepth}`)
+}
+
+function assertObjectDepth (schema, maxDepth, name) {
+  const stack = [{ value: schema, depth: 0, exit: false }]
+  const path = new WeakSet()
+
+  while (stack.length > 0) {
+    const entry = stack.pop()
+    const value = entry.value
+
+    if (typeof value !== 'object' || value === null) continue
+
+    // Schema maps and arrays add at most one container between schema nodes.
+    // Keep dependency traversals within the same stack-safety envelope while
+    // still allowing maxDepth schema nodes nested through `properties`.
+    if (entry.depth > maxDepth * 2) {
+      throw schemaDepthError(maxDepth, name)
+    }
+
+    if (entry.exit) {
+      path.delete(value)
+      continue
+    }
+
+    if (path.has(value)) {
+      throw new Error('schema contains a circular object reference; use $ref instead')
+    }
+    path.add(value)
+    stack.push({ value, depth: entry.depth, exit: true })
+
+    for (const key in value) {
+      stack.push({ value: value[key], depth: entry.depth + 1, exit: false })
+    }
+  }
+}
+
+function assertSchemaDepth (schema, maxDepth, name) {
+  const stack = [{ schema, depth: 0 }]
+
+  while (stack.length > 0) {
+    const entry = stack.pop()
+    const currentSchema = entry.schema
+
+    if (entry.depth > maxDepth) {
+      throw schemaDepthError(maxDepth, name)
+    }
+
+    if (typeof currentSchema !== 'object' || currentSchema === null) continue
+
+    const nestedDepth = entry.depth + 1
+
+    for (const keyword of singleSchemaKeywords) {
+      if (typeof currentSchema[keyword] === 'object' && currentSchema[keyword] !== null) {
+        stack.push({ schema: currentSchema[keyword], depth: nestedDepth })
+      }
+    }
+
+    for (const keyword of arraySchemaKeywords) {
+      const schemas = currentSchema[keyword]
+      if (Array.isArray(schemas)) {
+        for (const nestedSchema of schemas) {
+          stack.push({ schema: nestedSchema, depth: nestedDepth })
+        }
+      }
+    }
+
+    const items = currentSchema.items
+    if (Array.isArray(items)) {
+      for (const nestedSchema of items) {
+        stack.push({ schema: nestedSchema, depth: nestedDepth })
+      }
+    } else if (typeof items === 'object' && items !== null) {
+      stack.push({ schema: items, depth: nestedDepth })
+    }
+
+    for (const keyword of objectSchemaKeywords) {
+      const schemas = currentSchema[keyword]
+      if (typeof schemas === 'object' && schemas !== null) {
+        for (const key of Object.keys(schemas)) {
+          stack.push({ schema: schemas[key], depth: nestedDepth })
+        }
+      }
+    }
+
+    const dependencies = currentSchema.dependencies
+    if (typeof dependencies === 'object' && dependencies !== null) {
+      for (const key of Object.keys(dependencies)) {
+        const dependency = dependencies[key]
+        if (!Array.isArray(dependency)) {
+          stack.push({ schema: dependency, depth: nestedDepth })
+        }
+      }
+    }
+  }
+}
+
 function isValidSchema (schema, name) {
   if (!validate(schema)) {
     if (name) {
@@ -57,27 +187,64 @@ function isValidSchema (schema, name) {
 }
 
 function resolveRef (context, location) {
-  const ref = location.schema.$ref
+  const seen = new Set()
+  let depth = 0
 
-  let hashIndex = ref.indexOf('#')
-  if (hashIndex === -1) {
-    hashIndex = ref.length
-  }
+  while (location.schema.$ref !== undefined) {
+    const ref = location.schema.$ref
+    const locationRef = location.getSchemaRef()
 
-  const schemaId = ref.slice(0, hashIndex) || location.schemaId
-  const jsonPointer = ref.slice(hashIndex) || '#'
+    if (seen.has(locationRef)) {
+      throw new Error(`Cannot resolve circular reference "${ref}"`)
+    }
+    seen.add(locationRef)
+
+    if (depth++ > context.maxDepth) {
+      throw schemaDepthError(context.maxDepth)
+    }
+
+    let hashIndex = ref.indexOf('#')
+    if (hashIndex === -1) {
+      hashIndex = ref.length
+    }
+
+    const schemaId = ref.slice(0, hashIndex) || location.schemaId
+    const jsonPointer = ref.slice(hashIndex) || '#'
+
+    const schema = context.refResolver.getSchema(schemaId, jsonPointer)
+    if (schema === null) {
+      throw new Error(`Cannot find reference "${ref}"`)
+    }
 
-  const schema = context.refResolver.getSchema(schemaId, jsonPointer)
-  if (schema === null) {
-    throw new Error(`Cannot find reference "${ref}"`)
+    location = new Location(schema, schemaId, jsonPointer)
   }
 
-  const newLocation = new Location(schema, schemaId, jsonPointer)
-  if (schema.$ref !== undefined) {
-    return resolveRef(context, newLocation)
+  return location
+}
+
+function getSchemaDependencies (refResolver, schemaId) {
+  const dependencies = {}
+  const processed = new Set()
+  const pending = [schemaId]
+
+  while (pending.length > 0) {
+    const currentSchemaId = pending.pop()
+    if (processed.has(currentSchemaId)) continue
+    processed.add(currentSchemaId)
+
+    for (const ref of refResolver.getSchemaRefs(currentSchemaId)) {
+      const dependencySchemaId = ref.schemaId
+      if (
+        dependencySchemaId === currentSchemaId ||
+        dependencies[dependencySchemaId] !== undefined
+      ) continue
+
+      dependencies[dependencySchemaId] = refResolver.getSchema(dependencySchemaId)
+      pending.push(dependencySchemaId)
+    }
   }
 
-  return newLocation
+  return dependencies
 }
 
 function getMergedLocation (context, mergedSchemaId) {
@@ -92,6 +259,14 @@ function getSchemaId (schema, rootSchemaId) {
   return rootSchemaId
 }
 
+// a schema ref on a comment line of the generated code: a line terminator in a property name
+// would end the comment and turn the rest of the name into code. JSON.stringify covers \n and
+// \r, the two separators JS also treats as line terminators are escaped by hand
+const LINE_SEPARATORS = /[\u2028\u2029]/g
+function asComment (schemaRef) {
+  return JSON.stringify(schemaRef).replace(LINE_SEPARATORS, (c) => '\\u' + c.charCodeAt(0).toString(16))
+}
+
 function getSafeSchemaRef (context, location) {
   let schemaRef = location.getSchemaRef() || ''
   if (schemaRef.startsWith(context.rootSchemaId)) {
@@ -100,11 +275,59 @@ function getSafeSchemaRef (context, location) {
   return schemaRef
 }
 
-function build (schema, options) {
-  isValidSchema(schema)
+function getValidatorSchemaRef (context, location) {
+  let schemaRef = location.getSchemaRef()
+  const schema = location.schema
 
+  // A schema that is only a registered $ref can validate against that target
+  // instead of a JSON-pointer path through the root schema.
+  if (
+    typeof schema.$ref !== 'string' ||
+    Object.keys(schema).length !== 1
+  ) {
+    return schemaRef
+  }
+
+  const ref = schema.$ref
+  const hashIndex = ref.indexOf('#')
+  const refSchemaId = hashIndex === -1 ? ref : ref.slice(0, hashIndex)
+  const refJsonPointer = hashIndex === -1 ? '' : ref.slice(hashIndex)
+  const isBareRef = refJsonPointer === '' || refJsonPointer === '#'
+  const isNamedFragmentRef = NAMED_FRAGMENT_REF.test(refJsonPointer)
+  const isJsonPointerRef = refJsonPointer.startsWith('#/')
+
+  if (
+    (isBareRef || isNamedFragmentRef || isJsonPointerRef) &&
+    refSchemaId &&
+    context.refResolver.hasSchema(refSchemaId)
+  ) {
+    const refSchema = context.refResolver.getSchema(refSchemaId)
+    const refSubSchema = isBareRef
+      ? refSchema
+      : context.refResolver.getSchema(refSchemaId, refJsonPointer)
+    const hasRelativeSchemaId = (
+      typeof refSchema.$id === 'string' &&
+      refSchema.$id.charAt(0) === '#'
+    )
+    if (
+      refSubSchema !== null &&
+      (!hasRelativeSchemaId || refSchema.$id === refJsonPointer)
+    ) {
+      schemaRef = refSchemaId + (isBareRef ? '#' : refJsonPointer)
+    }
+  }
+
+  return schemaRef
+}
+
+function build (schema, options) {
   options = options || {}
 
+  const maxDepth = getMaxDepth(options)
+  assertObjectDepth(schema, maxDepth)
+  assertSchemaDepth(schema, maxDepth)
+  isValidSchema(schema)
+
   const context = {
     functions: [],
     functionsCounter: 0,
@@ -113,10 +336,14 @@ function build (schema, options) {
     refResolver: new RefResolver(),
     rootSchemaId: schema.$id || `__fjs_root_${schemaIdCounter++}`,
     validatorSchemasIds: new Set(),
+    validatorSchemaRefs: new Set(),
     mergedSchemasIds: new Map(),
+    maxDepth,
     recursiveSchemas: new Set(),
     recursivePaths: new Set(),
     buildingSet: new Set(),
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default',
     uid: 0
   }
 
@@ -130,6 +357,8 @@ function build (schema, options) {
       const schema = options.schema[key]
       const schemaId = getSchemaId(schema, key)
       if (!context.refResolver.hasSchema(schemaId)) {
+        assertObjectDepth(schema, maxDepth, key)
+        assertSchemaDepth(schema, maxDepth, key)
         isValidSchema(schema, key)
         context.refResolver.addSchema(schema, key)
       }
@@ -144,7 +373,7 @@ function build (schema, options) {
 
   if (options.largeArrayMechanism) {
     if (validLargeArrayMechanisms.has(options.largeArrayMechanism)) {
-      largeArrayMechanism = options.largeArrayMechanism
+      context.largeArrayMechanism = options.largeArrayMechanism
     } else {
       throw new Error(`Unsupported large array mechanism ${options.largeArrayMechanism}`)
     }
@@ -155,11 +384,11 @@ function build (schema, options) {
     let parsedNumber
 
     if (largeArraySizeType === 'string' && Number.isFinite((parsedNumber = Number.parseInt(options.largeArraySize, 10)))) {
-      largeArraySize = parsedNumber
+      context.largeArraySize = parsedNumber
     } else if (largeArraySizeType === 'number' && Number.isInteger(options.largeArraySize)) {
-      largeArraySize = options.largeArraySize
+      context.largeArraySize = options.largeArraySize
     } else if (largeArraySizeType === 'bigint') {
-      largeArraySize = Number(options.largeArraySize)
+      context.largeArraySize = Number(options.largeArraySize)
     } else {
       throw new Error(`Unsupported large array size. Expected integer-like, got ${typeof options.largeArraySize} with value ${options.largeArraySize}`)
     }
@@ -208,18 +437,25 @@ function build (schema, options) {
   }
 
   const serializer = new Serializer(options)
-  const validator = new Validator(options.ajv)
+  const validator = new Validator(
+    options.ajv,
+    options.mode === 'standalone' && options.inlineValidators
+  )
 
   for (const schemaId of context.validatorSchemasIds) {
     const schema = context.refResolver.getSchema(schemaId)
     validator.addSchema(schema, schemaId)
 
-    const dependencies = context.refResolver.getSchemaDependencies(schemaId)
+    const dependencies = getSchemaDependencies(context.refResolver, schemaId)
     for (const [schemaId, schema] of Object.entries(dependencies)) {
       validator.addSchema(schema, schemaId)
     }
   }
 
+  if (options.compileValidators) {
+    validator.compileSchemas(context.validatorSchemaRefs)
+  }
+
   if (options.mode === 'debug') {
     return {
       validator,
@@ -329,7 +565,12 @@ function buildExtraObjectPropertiesSerializer (context, location, addComma, objV
   const additionalPropertiesLocation = location.getPropertyLocation('additionalProperties')
   const additionalPropertiesSchema = additionalPropertiesLocation.schema
 
-  if (additionalPropertiesSchema !== undefined) {
+  // `additionalProperties: false` means every property that is not declared in
+  // `properties` nor matched by `patternProperties` is dropped, so no branch is
+  // emitted for it. Without this guard the `false` schema reaches buildValue,
+  // which serializes any boolean schema with `JSON.stringify(value)` and lets
+  // the property through.
+  if (additionalPropertiesSchema !== undefined && additionalPropertiesSchema !== false) {
     if (additionalPropertiesSchema === true) {
       code += `
         ${addComma}
@@ -447,12 +688,17 @@ function buildInnerObject (context, location, objVar) {
       const value = `value_${key.replace(/[^a-zA-Z0-9]/g, '_')}_${context.uid++}`
       const defaultValue = propertyLocation.schema.default
       const isRequired = requiredProperties.includes(key) // Should be false here but good to keep
+      // Select a complete prefix so the comma does not need a separate concatenation.
+      const propertyPrefix = sanitizedKey + ':'
+      const addProperty = needsRuntimeComma
+        ? `json += addComma_${localUid} ? ${JSON.stringify(',' + propertyPrefix)} : ${JSON.stringify(propertyPrefix)}
+           addComma_${localUid} = true`
+        : `json += ${JSON.stringify(propertyPrefix)}`
 
       code += `
           const ${value} = ${objVar}[${sanitizedKey}]
           if (${value} !== undefined) {
-            ${addComma}
-            json += ${JSON.stringify(sanitizedKey + ':')}
+            ${addProperty}
             ${buildValue(context, propertyLocation, `${value}`)}
           }`
 
@@ -568,7 +814,7 @@ function buildObject (context, location, input) {
     const schemaRef = getSafeSchemaRef(context, location)
 
     const functionCode = `
-      // ${schemaRef}
+      // ${asComment(schemaRef)}
       function ${functionName} (input) {
         const obj = ${toJSON('input')}
         if (obj === null) return ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_OBJECT'}
@@ -628,14 +874,14 @@ function buildArray (context, location, input) {
 
     let functionCode = `
     function ${functionName} (obj) {
-      // ${schemaRef}
+      // ${asComment(schemaRef)}
       let json = ''
   `
 
     functionCode += `
     if (obj === null) return ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_ARRAY'}
     if (!Array.isArray(obj)) {
-      throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
+      throw new TypeError(${JSON.stringify(`The value of '${schemaRef}' does not match schema definition.`)})
     }
     const arrayLength = obj.length
   `
@@ -648,8 +894,8 @@ function buildArray (context, location, input) {
     `
     }
 
-    if (largeArrayMechanism === 'json-stringify') {
-      functionCode += `if (arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+    if (context.largeArrayMechanism === 'json-stringify') {
+      functionCode += `if (arrayLength >= ${context.largeArraySize}) return JSON.stringify(obj)\n`
     }
 
     functionCode += `
@@ -720,7 +966,7 @@ function buildArray (context, location, input) {
     if (${objVar} === null) {
       json += ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_ARRAY'}
     } else if (!Array.isArray(${objVar})) {
-      throw new TypeError(\`The value of '${safeSchemaRef}' does not match schema definition.\`)
+      throw new TypeError(${JSON.stringify(`The value of '${safeSchemaRef}' does not match schema definition.`)})
     } else {
       const arrayLength_${objVar} = ${objVar}.length
   `
@@ -733,8 +979,8 @@ function buildArray (context, location, input) {
     `
   }
 
-  if (largeArrayMechanism === 'json-stringify') {
-    inlinedCode += `if (arrayLength_${objVar} >= ${largeArraySize}) json += JSON.stringify(${objVar})\n else {`
+  if (context.largeArrayMechanism === 'json-stringify') {
+    inlinedCode += `if (arrayLength_${objVar} >= ${context.largeArraySize}) json += JSON.stringify(${objVar})\n else {`
   }
 
   inlinedCode += `
@@ -791,7 +1037,7 @@ function buildArray (context, location, input) {
     json += JSON_STR_END_ARRAY
   `
 
-  if (largeArrayMechanism === 'json-stringify') {
+  if (context.largeArrayMechanism === 'json-stringify') {
     inlinedCode += '}'
   }
 
@@ -900,6 +1146,17 @@ function buildMultiTypeSerializer (context, location, input) {
         `
         break
       }
+      case 'object': {
+        // An array is `typeof === 'object'`, so it would otherwise be captured
+        // by this branch and serialized as an object (dropping its items). Exclude
+        // arrays here so a sibling `array` type in the same `type` list can match.
+        code += `
+          ${statement}((typeof ${input} === "object" && !Array.isArray(${input})) || ${input} === null) {
+            ${nestedResult}
+          }
+        `
+        break
+      }
       default: {
         code += `
           ${statement}(typeof ${input} === "${type}" || ${input} === null) {
@@ -911,7 +1168,7 @@ function buildMultiTypeSerializer (context, location, input) {
     }
   })
   code += `
-    else throw new TypeError(\`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.\`)
+    else throw new TypeError(${JSON.stringify(`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.`)})
   `
 
   return code
@@ -971,9 +1228,13 @@ function buildSingleTypeSerializer (context, location, input) {
 
 function detectRecursiveSchemas (context, location) {
   const pathStack = new Set()
-  function traverse (location) {
+  function traverse (location, depth) {
     const schema = location.schema
-    if (typeof schema !== 'object' || schema === null) return
+    if (!schema || typeof schema !== 'object') return
+
+    if (depth > context.maxDepth) {
+      throw schemaDepthError(context.maxDepth)
+    }
 
     const schemaId = location.schemaId || ''
     const jsonPointer = location.jsonPointer || ''
@@ -994,65 +1255,66 @@ function detectRecursiveSchemas (context, location) {
     if (schema.$ref) {
       try {
         const res = resolveRef(context, location)
-        traverse(res)
+        traverse(res, depth)
       } catch (err) {
+        if (!err.message.startsWith('Cannot find reference')) throw err
         // Validation will handle missing refs later
       }
     }
 
-    if (schema.properties) {
-      const propertiesLocation = location.getPropertyLocation('properties')
-      for (const key in schema.properties) {
-        traverse(propertiesLocation.getPropertyLocation(key))
-      }
-    }
-    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-      traverse(location.getPropertyLocation('additionalProperties'))
-    }
-    if (schema.patternProperties) {
-      const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
-      for (const key in schema.patternProperties) {
-        traverse(patternPropertiesLocation.getPropertyLocation(key))
+    const nestedDepth = depth + 1
+
+    for (const keyword of singleSchemaKeywords) {
+      if (typeof schema[keyword] === 'object' && schema[keyword] !== null) {
+        traverse(location.getPropertyLocation(keyword), nestedDepth)
       }
     }
-    if (schema.items) {
-      const itemsLocation = location.getPropertyLocation('items')
-      if (Array.isArray(schema.items)) {
-        for (let i = 0; i < schema.items.length; i++) {
-          traverse(itemsLocation.getPropertyLocation(i))
+
+    for (const keyword of arraySchemaKeywords) {
+      const schemas = schema[keyword]
+      if (Array.isArray(schemas)) {
+        const schemasLocation = location.getPropertyLocation(keyword)
+        const schemasLength = schemas.length
+        for (let i = 0; i < schemasLength; i++) {
+          traverse(schemasLocation.getPropertyLocation(i), nestedDepth)
         }
-      } else {
-        traverse(itemsLocation)
       }
     }
-    if (schema.additionalItems && typeof schema.additionalItems === 'object') {
-      traverse(location.getPropertyLocation('additionalItems'))
-    }
 
-    if (schema.oneOf) {
-      const oneOfLocation = location.getPropertyLocation('oneOf')
-      for (let i = 0; i < schema.oneOf.length; i++) {
-        traverse(oneOfLocation.getPropertyLocation(i))
+    const items = schema.items
+    if (Array.isArray(items)) {
+      const itemsLocation = location.getPropertyLocation('items')
+      const itemsLength = items.length
+      for (let i = 0; i < itemsLength; i++) {
+        traverse(itemsLocation.getPropertyLocation(i), nestedDepth)
       }
+    } else if (typeof items === 'object' && items !== null) {
+      traverse(location.getPropertyLocation('items'), nestedDepth)
     }
-    if (schema.anyOf) {
-      const anyOfLocation = location.getPropertyLocation('anyOf')
-      for (let i = 0; i < schema.anyOf.length; i++) {
-        traverse(anyOfLocation.getPropertyLocation(i))
+
+    for (const keyword of objectSchemaKeywords) {
+      const schemas = schema[keyword]
+      if (typeof schemas === 'object' && schemas !== null) {
+        const schemasLocation = location.getPropertyLocation(keyword)
+        for (const key in schemas) {
+          traverse(schemasLocation.getPropertyLocation(key), nestedDepth)
+        }
       }
     }
-    if (schema.allOf) {
-      const allOfLocation = location.getPropertyLocation('allOf')
-      for (let i = 0; i < schema.allOf.length; i++) {
-        traverse(allOfLocation.getPropertyLocation(i))
+
+    const dependencies = schema.dependencies
+    if (typeof dependencies === 'object' && dependencies !== null) {
+      const dependenciesLocation = location.getPropertyLocation('dependencies')
+      for (const key in dependencies) {
+        if (!Array.isArray(dependencies[key])) {
+          traverse(dependenciesLocation.getPropertyLocation(key), nestedDepth)
+        }
       }
     }
-    if (schema.then) traverse(location.getPropertyLocation('then'))
-    if (schema.else) traverse(location.getPropertyLocation('else'))
 
     pathStack.delete(fullPath)
   }
-  traverse(location)
+  traverse(location, 0)
 }
 
 function buildConstSerializer (location, input) {
@@ -1148,17 +1410,18 @@ function buildOneOf (context, location, input) {
     }
 
     const nestedResult = buildValue(context, mergedLocation, input)
-    const schemaRef = optionLocation.getSchemaRef()
+    const schemaRef = getValidatorSchemaRef(context, optionLocation)
+    context.validatorSchemaRefs.add(schemaRef)
 
     code += `
-      ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input})) {
+      ${index === 0 ? 'if' : 'else if'}(validator.validate(${JSON.stringify(schemaRef)}, ${input})) {
         ${nestedResult}
       }
     `
   }
 
   code += `
-    else throw new TypeError(\`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.\`)
+    else throw new TypeError(${JSON.stringify(`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.`)})
   `
 
   return code
@@ -1181,26 +1444,31 @@ function buildIfThenElse (context, location, input) {
   )
 
   const ifLocation = location.getPropertyLocation('if')
-  const ifSchemaRef = ifLocation.getSchemaRef()
-
-  const thenLocation = location.getPropertyLocation('then')
-  let thenMergedSchemaId = context.mergedSchemasIds.get(thenSchema)
-  let thenMergedLocation = null
-  if (thenMergedSchemaId) {
-    thenMergedLocation = getMergedLocation(context, thenMergedSchemaId)
-  } else {
-    thenMergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
-    context.mergedSchemasIds.set(thenSchema, thenMergedSchemaId)
+  const ifSchemaRef = getValidatorSchemaRef(context, ifLocation)
+  context.validatorSchemaRefs.add(ifSchemaRef)
+
+  // `then` is optional: a schema may pair `if` with `else` alone. In that case
+  // the true branch adds no keywords, so it serializes with the root schema.
+  let thenMergedLocation = rootLocation
+  if (thenSchema !== undefined) {
+    const thenLocation = location.getPropertyLocation('then')
+    let thenMergedSchemaId = context.mergedSchemasIds.get(thenSchema)
+    if (thenMergedSchemaId) {
+      thenMergedLocation = getMergedLocation(context, thenMergedSchemaId)
+    } else {
+      thenMergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+      context.mergedSchemasIds.set(thenSchema, thenMergedSchemaId)
 
-    thenMergedLocation = mergeLocations(context, thenMergedSchemaId, [
-      rootLocation,
-      thenLocation
-    ])
+      thenMergedLocation = mergeLocations(context, thenMergedSchemaId, [
+        rootLocation,
+        thenLocation
+      ])
+    }
   }
 
   if (!elseSchema) {
     return `
-      if (validator.validate("${ifSchemaRef}", ${input})) {
+      if (validator.validate(${JSON.stringify(ifSchemaRef)}, ${input})) {
         ${buildValue(context, thenMergedLocation, input)}
       } else {
         ${buildValue(context, rootLocation, input)}
@@ -1224,7 +1492,7 @@ function buildIfThenElse (context, location, input) {
   }
 
   return `
-    if (validator.validate("${ifSchemaRef}", ${input})) {
+    if (validator.validate(${JSON.stringify(ifSchemaRef)}, ${input})) {
       ${buildValue(context, thenMergedLocation, input)}
     } else {
       ${buildValue(context, elseMergedLocation, input)}
@@ -1252,7 +1520,7 @@ function buildValue (context, location, input) {
     return buildOneOf(context, location, input)
   }
 
-  if (schema.if && schema.then) {
+  if (schema.if && (schema.then || schema.else)) {
     return buildIfThenElse(context, location, input)
   }