joi-to-json 2.6.0 → 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 3.0.0
+
+- [BREAKING] Default enable feature: relation operator `and`, `or`, `nand`, `xor`, `oxor`.

package/README.md

@@ -95,6 +95,153 @@ const jsonSchema = parse(joiSchema)
 // const openApiSchema = parse(joiSchema, 'open-api')
 ```
 
+### Joi to OpenAPI
+
+Most Joi specifications result in the expected OpenAPI schema. 
+
+E.g.,
+
+```js
+const joi = require('joi')
+const { dump } = require('js-yaml')
+const { writeFile } = require('fs/promises')
+
+const joiSchema = joi.object().keys({
+  uuid: joi.string().uuid({ version: ['uuidv3', 'uuidv5'] }),
+  nickName: joi.string().required().example('鹄思乱想').description('Hero Nickname').min(3).max(20).pattern(/^[a-z]+$/, { name: 'alpha', invert: true }),
+  avatar: joi.string().required().uri(),
+  email: joi.string().email(),
+  ip: joi.string().ip({ version: ['ipv4', 'ipv6'] }),
+  hostname: joi.string().hostname().insensitive(),
+  gender: joi.string().valid('Male', 'Female', '', null).default('Male'),
+  isoDateString: joi.string().isoDate(),
+  isoDurationString: joi.string().isoDuration(),
+  birthday: joi.date().iso(),
+  certificate: joi.binary().encoding('base64'),
+  tags: joi.array().items(joi.string().required()).length(2),
+  nested: joi.object().keys({
+    key: joi.string()
+  }).unknown(true)
+}).unknown(false)
+
+async function writeYAML(targetPath) {
+  const openApiSchema = parse(joiSchema, 'open-api')
+
+  const openApiSchemaYAML = dump(openApiSchema, {lineWidth: 120, noCompatMode: true})
+  await writeFile(targetPath, openApiSchemaYAML)
+}
+```
+
+results in
+
+```yaml
+type: object
+required:
+  - nickName
+  - avatar
+properties:
+  uuid:
+    type: string
+    format: uuid
+  nickName:
+    description: Hero Nickname
+    type: string
+    pattern: ^[a-z]+$
+    minLength: 3,
+    maxLength: 20,
+    example: 鹄思乱想
+  avatar:
+    type: string
+    format: uri
+  email:
+    type: string
+    format: email
+  ip:
+    type: string
+    oneOf:
+      - format: ipv4
+      - format: ipv6
+  hostname:
+    type: string
+    format: hostname
+  gender:
+    type: string
+    default: Male
+    enum:
+      - Male
+      - Female
+      - ''
+      - null
+    nullable: true
+  isoDateString:
+    type: string
+    format: date-time
+  isoDurationString:
+    type: string
+    format: duration
+  birthday:
+    type: string
+    format: date-time
+  certificate:
+    type: string
+    format: binary
+  tags:
+    type: array
+    items:
+      type: string
+    minItems: 2
+    maxItems: 2
+  nested:
+    type: object
+    properties:
+      key:
+        type: string
+    additionalProperties: true    
+additionalProperties: false
+```
+
+Some OpenAPI features are not supported directly in Joi, but Joi schemas can be annotated with `joi.any().meta({…})` 
+to get them in the OpenAPI schema:
+
+```js
+…
+
+const joiSchema = joi.object().keys({
+  deprecatedProperty: joi.string().meta({ deprecated: true }).required(),
+  readOnlyProperty: joi.string().meta({ readOnly: true }),
+  writeOnlyProperty: joi.string().meta({ writeOnly: true }),
+  xMeta: joi.string().meta({ 'x-meta': 42 }),
+  unknownMetaProperty: joi.string().meta({ unknownMeta: 42 })
+}).unknown(true)
+
+…
+```
+
+begets:
+
+```yaml
+type: object
+required:
+  - deprecatedProperty
+properties:
+  deprecatedProperty:
+    type: string
+    deprecated: true
+  readOnlyProperty:
+    type: string
+    readOnly: true
+  writeOnlyProperty:
+    type: string
+    writeOnly: true
+  xMeta:
+    type: string
+    x-meta: 42
+  unknownMetaProperty:
+    type: string
+    # unknownMeta is not exported
+additionalProperties: true
+```
+
 ## Browser support
 For generating JSON Schema in a browser you should use below import syntax for `joi` library in order to work because the `joi` browser minimized build does not have `describe` api which the `joi-to-json` relies on.
 
@@ -102,6 +249,10 @@ For generating JSON Schema in a browser you should use below import syntax for `
   import Joi from 'joi/lib/index';
 ```
 
+## Special Joi Operator Support
+
+* [Logical Relation Operator](./docs/logical_rel_support.md)
+
 ## Test
 
 >npm run test

package/index.js

@@ -22,7 +22,7 @@ const parsers = {
   'open-api': JoiOpenApiSchemaParser
 }
 
-function parse(joiObj, type = 'json', definitions = {}) {
+function parse(joiObj, type = 'json', definitions = {}, parserOptions = {}) {
   if (typeof joiObj.describe !== 'function') {
     throw new Error('Not an joi object.')
   }
@@ -59,7 +59,7 @@ function parse(joiObj, type = 'json', definitions = {}) {
     throw new Error(`No parser is registered for ${type}`)
   }
 
-  return new parser().parse(joiBaseSpec, definitions)
+  return new parser(parserOptions).parse(joiBaseSpec, definitions)
 }
 
 module.exports = parse

package/lib/convertors/v12.js

@@ -1,247 +1,258 @@
-const _ = require('lodash')
-
-class JoiSpecConvertor {
-  constructor() {}
-
-  static getVersion(joiObj) {
-    return joiObj._currentJoi.version
-  }
-
-  static getSupportVersion() {
-    return '12'
-  }
-
-  _convertObject(joiObj) {
-    if (joiObj.children) {
-      joiObj.keys = joiObj.children
-      delete joiObj.children
-    }
-
-    _.each(joiObj.keys, (value, _key) => {
-      this.toBaseSpec(value)
-    })
-
-    _.each(joiObj.patterns, (pattern, _idx) => {
-      this.toBaseSpec(pattern.rule)
-    })
-  }
-
-  _convertDate(joiObj) {
-    if (joiObj.flags.timestamp) {
-      joiObj.flags.format = joiObj.flags.timestamp
-      delete joiObj.flags.timestamp
-      delete joiObj.flags.multiplier
-    } else if (joiObj.flags.format = {}) {
-      joiObj.flags.format = 'iso'
-    }
-  }
-
-  _convertAlternatives(joiObj) {
-    let isWhenCase = false
-    if (joiObj.alternatives.length === 1) {
-      const condition = joiObj.alternatives[0]
-      isWhenCase = !!condition.then || !!condition.otherwise
-    }
-
-    if (isWhenCase) {
-      // when case
-      joiObj.type = 'any'
-      joiObj.whens = joiObj.alternatives
-
-      if (joiObj.flags.presence === 'ignore') {
-        // FIXME: Not sure when this flag is set.
-        delete joiObj.flags.presence
-      }
-      if (joiObj.whens.peek) {
-        joiObj.whens.is = joiObj.whens.peek
-        delete joiObj.whens.peek
-      }
-
-      joiObj.whens[0] = _.mapValues(joiObj.whens[0], (value, condition) => {
-        switch (condition) {
-          case 'is':
-            this.toBaseSpec(value)
-            value.type = 'any'
-            // FIXME: Not sure when this is set.
-            value.allow.splice(0, 0, { 'override': true })
-            break
-          case 'otherwise':
-            this.toBaseSpec(value)
-            break
-          case 'then':
-            this.toBaseSpec(value)
-            break
-          case 'ref':
-            if (value.indexOf('ref:') === 0) {
-              value = {
-                path: value.replace('ref:', '').split('.')
-              }
-            }
-            break
-        }
-        return value
-      })
-
-      delete joiObj.alternatives
-      delete joiObj.base
-    } else {
-      joiObj.matches = _.map(joiObj.alternatives, (alternative) => {
-        return {
-          schema: this.toBaseSpec(alternative)
-        }
-      })
-      delete joiObj.alternatives
-    }
-  }
-
-  _convertString(joiObj) {
-    delete joiObj.options
-
-    _.each(joiObj.rules, (rule, _idx) => {
-      const name = rule.name
-      if (['min', 'max'].includes(name)) {
-        rule.args = {
-          limit: rule.arg
-        }
-      } else if (['lowercase', 'uppercase'].includes(name)) {
-        rule.name = 'case'
-        rule.args = {
-          direction: name.replace('case', '')
-        }
-        delete joiObj.flags.case
-      } else if (rule.arg) {
-        rule.args = {
-          options: rule.arg
-        }
-      }
-      if (name === 'regex') {
-        rule.name = 'pattern'
-        rule.args.regex = rule.arg.pattern.toString()
-        delete rule.args.options.pattern
-      }
-      delete rule.arg
-    })
-  }
-
-  _convertNumber(joiObj) {
-    _.each(joiObj.rules, (rule, _idx) => {
-      const name = rule.name
-      if (['positive', 'negative'].includes(name)) {
-        rule.args = {
-          sign: name
-        }
-        rule.name = 'sign'
-      }
-      if (['greater', 'less', 'min', 'max', 'precision'].includes(name)) {
-        rule.args = {
-          limit: rule.arg
-        }
-      }
-      if (name === 'multiple') {
-        rule.args = {
-          base: rule.arg
-        }
-      }
-      delete rule.arg
-    })
-
-    if (joiObj.flags.precision) {
-      delete joiObj.flags.precision
-    }
-  }
-
-  _convertBoolean(joiObj) {
-    if (joiObj.flags.insensitive === false) {
-      joiObj.flags.sensitive = true
-    }
-    delete joiObj.flags.insensitive
-  }
-
-  _convertArray(joiObj) {
-    if (joiObj.flags.sparse === false) {
-      delete joiObj.flags.sparse
-    }
-
-    _.each(joiObj.rules, (rule, _idx) => {
-      const name = rule.name
-      if (['min', 'max', 'length'].includes(name)) {
-        rule.args = {
-          limit: rule.arg
-        }
-      }
-      delete rule.arg
-    })
-
-    _.each(joiObj.items, (item, _idx) => {
-      this.toBaseSpec(item)
-    })
-  }
-
-  _convertExamples(_joiObj) {
-  }
-
-  toBaseSpec(joiObj) {
-    joiObj.flags = joiObj.flags || {}
-
-    if (joiObj.flags.allowOnly) {
-      joiObj.flags.only = joiObj.flags.allowOnly
-      delete joiObj.flags.allowOnly
-    }
-    if (joiObj.flags.allowUnknown) {
-      joiObj.flags.unknown = joiObj.flags.allowUnknown
-      delete joiObj.flags.allowUnknown
-    }
-    if (joiObj.description) {
-      joiObj.flags.description = joiObj.description
-      delete joiObj.description
-    }
-    if (joiObj.options) {
-      joiObj.preferences = joiObj.options
-      delete joiObj.options
-    }
-    if (joiObj.valids) {
-      joiObj.allow = joiObj.valids
-      delete joiObj.valids
-    }
-    if (joiObj.meta) {
-      joiObj.metas = joiObj.meta
-      delete joiObj.meta
-    }
-    delete joiObj.invalids
-
-    this._convertExamples(joiObj)
-
-    switch (joiObj.type) {
-      case 'object':
-        this._convertObject(joiObj)
-        break
-      case 'date':
-        this._convertDate(joiObj)
-        break
-      case 'alternatives':
-        this._convertAlternatives(joiObj)
-        break
-      case 'string':
-        this._convertString(joiObj)
-        break
-      case 'number':
-        this._convertNumber(joiObj)
-        break
-      case 'boolean':
-        this._convertBoolean(joiObj)
-        break
-      case 'array':
-        this._convertArray(joiObj)
-        break
-      default:
-        break
-    }
-    if (_.isEmpty(joiObj.flags)) {
-      delete joiObj.flags
-    }
-
-    return joiObj
-  }
-}
-
-module.exports = JoiSpecConvertor
+const _ = require('lodash')
+
+class JoiSpecConvertor {
+  constructor() {}
+
+  static getVersion(joiObj) {
+    return joiObj._currentJoi.version
+  }
+
+  static getSupportVersion() {
+    return '12'
+  }
+
+  _convertObject(joiObj) {
+    if (joiObj.children) {
+      joiObj.keys = joiObj.children
+      delete joiObj.children
+    }
+
+    _.each(joiObj.keys, (value, _key) => {
+      this.toBaseSpec(value)
+    })
+
+    _.each(joiObj.patterns, (pattern, _idx) => {
+      this.toBaseSpec(pattern.rule)
+    })
+
+    this._convertDependencies(joiObj)
+  }
+
+  _convertDependencies(joiObj) {
+    _.each(joiObj.dependencies, (dependency) => {
+      if (dependency.type) {
+        dependency.rel = dependency.type
+        delete dependency.type
+      }
+    })
+  }
+
+  _convertDate(joiObj) {
+    if (joiObj.flags.timestamp) {
+      joiObj.flags.format = joiObj.flags.timestamp
+      delete joiObj.flags.timestamp
+      delete joiObj.flags.multiplier
+    } else if (joiObj.flags.format = {}) {
+      joiObj.flags.format = 'iso'
+    }
+  }
+
+  _convertAlternatives(joiObj) {
+    let isWhenCase = false
+    if (joiObj.alternatives.length === 1) {
+      const condition = joiObj.alternatives[0]
+      isWhenCase = !!condition.then || !!condition.otherwise
+    }
+
+    if (isWhenCase) {
+      // when case
+      joiObj.type = 'any'
+      joiObj.whens = joiObj.alternatives
+
+      if (joiObj.flags.presence === 'ignore') {
+        // FIXME: Not sure when this flag is set.
+        delete joiObj.flags.presence
+      }
+      if (joiObj.whens.peek) {
+        joiObj.whens.is = joiObj.whens.peek
+        delete joiObj.whens.peek
+      }
+
+      joiObj.whens[0] = _.mapValues(joiObj.whens[0], (value, condition) => {
+        switch (condition) {
+          case 'is':
+            this.toBaseSpec(value)
+            value.type = 'any'
+            // FIXME: Not sure when this is set.
+            value.allow.splice(0, 0, { 'override': true })
+            break
+          case 'otherwise':
+            this.toBaseSpec(value)
+            break
+          case 'then':
+            this.toBaseSpec(value)
+            break
+          case 'ref':
+            if (value.indexOf('ref:') === 0) {
+              value = {
+                path: value.replace('ref:', '').split('.')
+              }
+            }
+            break
+        }
+        return value
+      })
+
+      delete joiObj.alternatives
+      delete joiObj.base
+    } else {
+      joiObj.matches = _.map(joiObj.alternatives, (alternative) => {
+        return {
+          schema: this.toBaseSpec(alternative)
+        }
+      })
+      delete joiObj.alternatives
+    }
+  }
+
+  _convertString(joiObj) {
+    delete joiObj.options
+
+    _.each(joiObj.rules, (rule, _idx) => {
+      const name = rule.name
+      if (['min', 'max'].includes(name)) {
+        rule.args = {
+          limit: rule.arg
+        }
+      } else if (['lowercase', 'uppercase'].includes(name)) {
+        rule.name = 'case'
+        rule.args = {
+          direction: name.replace('case', '')
+        }
+        delete joiObj.flags.case
+      } else if (rule.arg) {
+        rule.args = {
+          options: rule.arg
+        }
+      }
+      if (name === 'regex') {
+        rule.name = 'pattern'
+        rule.args.regex = rule.arg.pattern.toString()
+        delete rule.args.options.pattern
+      }
+      delete rule.arg
+    })
+  }
+
+  _convertNumber(joiObj) {
+    _.each(joiObj.rules, (rule, _idx) => {
+      const name = rule.name
+      if (['positive', 'negative'].includes(name)) {
+        rule.args = {
+          sign: name
+        }
+        rule.name = 'sign'
+      }
+      if (['greater', 'less', 'min', 'max', 'precision'].includes(name)) {
+        rule.args = {
+          limit: rule.arg
+        }
+      }
+      if (name === 'multiple') {
+        rule.args = {
+          base: rule.arg
+        }
+      }
+      delete rule.arg
+    })
+
+    if (joiObj.flags.precision) {
+      delete joiObj.flags.precision
+    }
+  }
+
+  _convertBoolean(joiObj) {
+    if (joiObj.flags.insensitive === false) {
+      joiObj.flags.sensitive = true
+    }
+    delete joiObj.flags.insensitive
+  }
+
+  _convertArray(joiObj) {
+    if (joiObj.flags.sparse === false) {
+      delete joiObj.flags.sparse
+    }
+
+    _.each(joiObj.rules, (rule, _idx) => {
+      const name = rule.name
+      if (['min', 'max', 'length'].includes(name)) {
+        rule.args = {
+          limit: rule.arg
+        }
+      }
+      delete rule.arg
+    })
+
+    _.each(joiObj.items, (item, _idx) => {
+      this.toBaseSpec(item)
+    })
+  }
+
+  _convertExamples(_joiObj) {
+  }
+
+  toBaseSpec(joiObj) {
+    joiObj.flags = joiObj.flags || {}
+
+    if (joiObj.flags.allowOnly) {
+      joiObj.flags.only = joiObj.flags.allowOnly
+      delete joiObj.flags.allowOnly
+    }
+    if (joiObj.flags.allowUnknown) {
+      joiObj.flags.unknown = joiObj.flags.allowUnknown
+      delete joiObj.flags.allowUnknown
+    }
+    if (joiObj.description) {
+      joiObj.flags.description = joiObj.description
+      delete joiObj.description
+    }
+    if (joiObj.options) {
+      joiObj.preferences = joiObj.options
+      delete joiObj.options
+    }
+    if (joiObj.valids) {
+      joiObj.allow = joiObj.valids
+      delete joiObj.valids
+    }
+    if (joiObj.meta) {
+      joiObj.metas = joiObj.meta
+      delete joiObj.meta
+    }
+    delete joiObj.invalids
+
+    this._convertExamples(joiObj)
+
+    switch (joiObj.type) {
+      case 'object':
+        this._convertObject(joiObj)
+        break
+      case 'date':
+        this._convertDate(joiObj)
+        break
+      case 'alternatives':
+        this._convertAlternatives(joiObj)
+        break
+      case 'string':
+        this._convertString(joiObj)
+        break
+      case 'number':
+        this._convertNumber(joiObj)
+        break
+      case 'boolean':
+        this._convertBoolean(joiObj)
+        break
+      case 'array':
+        this._convertArray(joiObj)
+        break
+      default:
+        break
+    }
+    if (_.isEmpty(joiObj.flags)) {
+      delete joiObj.flags
+    }
+
+    return joiObj
+  }
+}
+
+module.exports = JoiSpecConvertor

package/lib/parsers/json-draft-04.js

@@ -1,21 +1,25 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json')
-
-class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
-  _setNumberFieldProperties(fieldSchema, fieldDefn) {
-    super._setNumberFieldProperties(fieldSchema, fieldDefn)
-
-    if (typeof fieldSchema.minimum !== 'undefined' && fieldSchema.minimum === fieldSchema.exclusiveMinimum) {
-      fieldSchema.exclusiveMinimum = true
-    }
-    if (typeof fieldSchema.maximum !== 'undefined' && fieldSchema.maximum === fieldSchema.exclusiveMaximum) {
-      fieldSchema.exclusiveMaximum = true
-    }
-  }
-
-  _getLocalSchemaBasePath() {
-    return '#/definitions'
-  }
-}
-
-module.exports = JoiJsonDraftSchemaParser
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json')
+
+class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
+  constructor(opts = {}) {
+    super(_.merge({ logicalOpParser: { xor: null } }, opts))
+  }
+
+  _setNumberFieldProperties(fieldSchema, fieldDefn) {
+    super._setNumberFieldProperties(fieldSchema, fieldDefn)
+
+    if (typeof fieldSchema.minimum !== 'undefined' && fieldSchema.minimum === fieldSchema.exclusiveMinimum) {
+      fieldSchema.exclusiveMinimum = true
+    }
+    if (typeof fieldSchema.maximum !== 'undefined' && fieldSchema.maximum === fieldSchema.exclusiveMaximum) {
+      fieldSchema.exclusiveMaximum = true
+    }
+  }
+
+  _getLocalSchemaBasePath() {
+    return '#/definitions'
+  }
+}
+
+module.exports = JoiJsonDraftSchemaParser

package/lib/parsers/json.js

@@ -1,13 +1,84 @@
 /* eslint no-use-before-define: 'off' */
 const _ = require('lodash')
+const combinations = require('combinations')
+
+/**
+ * Default Joi logical operator (or/and/nand/xor/oxor) parsers
+ */
+const LOGICAL_OP_PARSER = {
+  or: function (schema, dependency) {
+    schema.anyOf = _.map(dependency.peers, (peer) => {
+      return { required: [peer] }
+    })
+  },
+  and: function (schema, dependency) {
+    schema.oneOf = [{ required: dependency.peers }]
+    schema.oneOf.push({
+      allOf: _.map(dependency.peers, (peer) => {
+        return { not: { required: [peer] } }
+      })
+    })
+  },
+  nand: function (schema, dependency) {
+    schema.not = { required: dependency.peers }
+  },
+  xor: function (schema, dependency) {
+    schema.if = {
+      propertyNames: { enum: dependency.peers },
+      minProperties: 2
+    }
+    schema.then = false
+    schema.else = {
+      oneOf: _.map(dependency.peers, (peer) => {
+        return { required: [peer] }
+      })
+    }
+  },
+  oxor: function (schema, dependency) {
+    schema.oneOf = _.map(dependency.peers, (peer) => {
+      return { required: [peer] }
+    })
+    schema.oneOf.push({
+      not: {
+        oneOf: _.map(combinations(dependency.peers, 1, 2), (combination) => {
+          return { required: combination }
+        })
+      }
+    })
+  }
+}
+
+/**
+ * Recognize the `joi.override` representation in `describe()` output.
+ *
+ * `joi.override` is a Symbol that can be used in `joi.any().valid(…)`
+ * statements, to reset the list of valid values. In `describe()` output, it
+ * turns up as an object with 1 property:
+ *
+ * ```
+ * { override: true }
+ * ```
+ */
+function isJoiOverride(e) {
+  return typeof e === 'object'
+         && e !== null
+         && Object.keys(e).length === 1
+         && e.override === true
+}
 
 class JoiJsonSchemaParser {
-  constructor() {
+  constructor(opts = {}) {
     this.childrenFieldName = this._getChildrenFieldName()
     this.optionsFieldName = this._getOptionsFieldName()
     this.ruleArgFieldName = this._getRuleArgFieldName()
     this.enumFieldName = this._getEnumFieldName()
     this.allowUnknownFlagName = this._getAllowUnknownFlagName()
+
+    if (opts.logicalOpParser === false) {
+      this.logicalOpParser = {}
+    } else {
+      this.logicalOpParser = _.merge({}, LOGICAL_OP_PARSER, opts.logicalOpParser)
+    }
   }
 
   parse(joiSpec, definitions = {}, level = 0) {
@@ -124,8 +195,9 @@ class JoiJsonSchemaParser {
 
   _getEnum(fieldDefn) {
     const enumList = fieldDefn[this.enumFieldName]
-    if (fieldDefn.flags && fieldDefn.flags.only && _.size(enumList) > 1) {
-      return _.uniq(enumList)
+    const filteredEnumList = enumList ? _.filter(enumList, e => !isJoiOverride(e)) : enumList
+    if (fieldDefn.flags && fieldDefn.flags.only && _.size(filteredEnumList) > 1) {
+      return _.uniq(filteredEnumList)
     }
   }
 
@@ -222,6 +294,39 @@ class JoiJsonSchemaParser {
     if (_.isEmpty(schema.required)) {
       delete schema.required
     }
+
+    this._setObjectDependencies(schema, joiSpec)
+  }
+
+  _setObjectDependencies(schema, joiSpec) {
+    if (!_.isArray(joiSpec.dependencies) || joiSpec.dependencies.length === 0) {
+      return
+    }
+
+    if (joiSpec.dependencies.length === 1) {
+      this._setDependencySubSchema(schema, joiSpec.dependencies[0])
+    } else {
+      schema.allOf = _.compact(_.map(joiSpec.dependencies, (dependency) => {
+        const subSchema = this._setDependencySubSchema({}, dependency)
+        if (_.isEmpty(subSchema)) {
+          return null
+        }
+        return subSchema
+      }))
+      if (schema.allOf.length === 0) {
+        // When the logicalOpParser is set to false
+        delete schema.allOf
+      }
+    }
+  }
+
+  _setDependencySubSchema(schema, dependency) {
+    const opParser = this.logicalOpParser[dependency.rel]
+    if (typeof opParser !== 'function') {
+      return schema
+    }
+    opParser(schema, dependency)
+    return schema
   }
 
   _setNumberFieldProperties(fieldSchema, fieldDefn) {

package/lib/parsers/open-api.js

@@ -1,83 +1,83 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json-draft-04')
-
-class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
-  parse(joiSpec, definitions = {}, level = 0) {
-    const fullSchema = super.parse(joiSpec, definitions, level)
-    const schema = _.pick(fullSchema, [
-      '$ref',
-      'title',
-      'multipleOf',
-      'maximum',
-      'exclusiveMaximum',
-      'minimum',
-      'exclusiveMinimum',
-      'maxLength',
-      'minLength',
-      'pattern',
-      'maxItems',
-      'minItems',
-      'uniqueItems',
-      'maxProperties',
-      'minProperties',
-      'required',
-      'enum',
-      'description',
-      'format',
-      'default',
-      'type',
-
-      'allOf',
-      'oneOf',
-      'anyOf',
-      'not',
-      'items',
-      'properties',
-      'additionalProperties',
-
-      'example',
-      'nullable'
-    ])
-
-    if (!_.isEmpty(joiSpec.metas)) {
-      _.each(joiSpec.metas, meta => {
-        _.each(meta, (value, key) => {
-          if (key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly') {
-            schema[key] = value
-          }
-        })
-      })
-    }
-
-    if (level === 0 && !_.isEmpty(definitions)) {
-      schema.schemas = definitions
-    }
-
-    if (fullSchema.const) {
-      schema.enum = [fullSchema.const]
-    }
-
-    return schema
-  }
-
-  _getLocalSchemaBasePath() {
-    return '#/components/schemas'
-  }
-
-  _setBasicProperties(fieldSchema, fieldDefn) {
-    super._setBasicProperties(fieldSchema, fieldDefn)
-
-    if (!_.isEmpty(fieldSchema.examples)) {
-      fieldSchema.example = fieldSchema.examples[0]
-    }
-  }
-
-  _addNullTypeIfNullable(fieldSchema, fieldDefn) {
-    const enums = _.get(fieldDefn, this.enumFieldName)
-    if (Array.isArray(enums) && enums.includes(null)) {
-      fieldSchema.nullable = true
-    }
-  }
-}
-
-module.exports = JoiOpenApiSchemaParser
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json-draft-04')
+
+class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
+  parse(joiSpec, definitions = {}, level = 0) {
+    const fullSchema = super.parse(joiSpec, definitions, level)
+    const schema = _.pick(fullSchema, [
+      '$ref',
+      'title',
+      'multipleOf',
+      'maximum',
+      'exclusiveMaximum',
+      'minimum',
+      'exclusiveMinimum',
+      'maxLength',
+      'minLength',
+      'pattern',
+      'maxItems',
+      'minItems',
+      'uniqueItems',
+      'maxProperties',
+      'minProperties',
+      'required',
+      'enum',
+      'description',
+      'format',
+      'default',
+      'type',
+
+      'allOf',
+      'oneOf',
+      'anyOf',
+      'not',
+      'items',
+      'properties',
+      'additionalProperties',
+
+      'example',
+      'nullable'
+    ])
+
+    if (!_.isEmpty(joiSpec.metas)) {
+      _.each(joiSpec.metas, meta => {
+        _.each(meta, (value, key) => {
+          if (key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly') {
+            schema[key] = value
+          }
+        })
+      })
+    }
+
+    if (level === 0 && !_.isEmpty(definitions)) {
+      schema.schemas = definitions
+    }
+
+    if (fullSchema.const) {
+      schema.enum = [fullSchema.const]
+    }
+
+    return schema
+  }
+
+  _getLocalSchemaBasePath() {
+    return '#/components/schemas'
+  }
+
+  _setBasicProperties(fieldSchema, fieldDefn) {
+    super._setBasicProperties(fieldSchema, fieldDefn)
+
+    if (!_.isEmpty(fieldSchema.examples)) {
+      fieldSchema.example = fieldSchema.examples[0]
+    }
+  }
+
+  _addNullTypeIfNullable(fieldSchema, fieldDefn) {
+    const enums = _.get(fieldDefn, this.enumFieldName)
+    if (Array.isArray(enums) && enums.includes(null)) {
+      fieldSchema.nullable = true
+    }
+  }
+}
+
+module.exports = JoiOpenApiSchemaParser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joi-to-json",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "joi to JSON / OpenAPI Schema Converter",
   "main": "index.js",
   "repository": {
@@ -23,6 +23,7 @@
     "oas"
   ],
   "dependencies": {
+    "combinations": "^1.0.0",
     "lodash": "^4.17.21",
     "semver-compare": "^1.0.0"
   },