joi-to-json 3.1.2 → 4.0.0

package/README.md

@@ -8,27 +8,19 @@ It's **The most powerful schema description language and data validator for Java
 Many times, we need to utilize this schema description to produce other output, such as Swagger OpenAPI doc.
 That is why I build [joi-route-to-swagger](https://github.com/kenspirit/joi-route-to-swagger) in the first place.
 
-At the beginning, `joi-route-to-swagger` relies on [joi-to-json-schema](https://github.com/lightsofapollo/joi-to-json-schema/) which utilizes many joi internal api or properties.  I believed there was reason.  Maybe joi did not provide the `describe` api way before.  But I always feel uncomfortable and think it's time to move on.
+At the beginning, `joi-route-to-swagger` relies on [joi-to-json-schema](https://github.com/lightsofapollo/joi-to-json-schema/) which utilizes many joi internal api or properties.  Maybe joi did not provide the `describe` api way before, but I always feel uncomfortable of relying on internal api.
 
 The intention of `joi-to-json` is to support converting different version's joi schema to [JSON Schema](https://json-schema.org) using `describe` api.
 
-## 2.0.0 is out
+The implementation of this JOI to JSON conversion tool is simply a pipeline of two components:
 
-It's a breaking change.
+1. Convertors
+  - Each JOI version has one convertor implementation.
+  - It converts the `joi.describe()` output to the baseline format (currently the v16 and v17 one)
 
-* Functionally, output format supports OpenAPI Schema other than purely JSON Schema.  
-
-* Technically, implementation theory has a big change:
-  - In v1.0.0, it directly converts `joi.describe()` to JSON schema using different parser implementations.
-  - In v2.0.0, `joi.describe()` of different versions are first converted to one base format, the latest version of `joi.describe()` output.  Then different parsers (JSON, OpenAPI) all refer to this base format.
-
-* The benefits of the change are:
-  - Easier to retire old version of joi.
-  - Easier to support more output formats.
-
-## Installation
-
->npm install joi-to-json
+2. Parsers
+  - Each supported output JSON format (e.g. JSON Draft 07, OpenAPI) has one parser implementation.
+  - All parsers converts the baseline format into its own format
 
 
 ## Joi Version Support
@@ -42,11 +34,14 @@ It's a breaking change.
   * 15.1.1
   * 16.1.8
 * joi
-  * 17.4.2
+  * 17.9.2
+
+Although the versions chosen are the latest one for each major version, It should support other minor versions as well.
 
-For all above versions, I have tested one complex joi object [fixtures](./fixtures) which covers most of the JSON schema attributes that can be described in joi schema.
 
-Although the versions chosen are the latest one for each major version, I believe it should be supporting other minor version as well.
+## Installation
+
+>npm install joi-to-json
 
 
 ## Usage
@@ -55,11 +50,11 @@ Only one API `parse` is available.  It's signature is `parse(joiObj, type = 'jso
 
 Currently supported output types:  
 * `json` - Default.  Stands for JSON Schema Draft 07
-* `open-api` - Stands for OpenAPI Schema
+* `open-api` - Stands for OpenAPI 3.0 Schema - an extended subset of JSON Schema Specification Wright Draft 00 (aka Draft 5)
 * `json-draft-04` - Stands for JSON Schema Draft 04
 * `json-draft-2019-09` - Stands for JSON Schema Draft 2019-09
 
-The output schema format are in [outputs](./outputs) under specific folders for different types.
+The output schema format are in [outputs](./outputs-parsers) under specific folders for different types.
 
 Sample code is as below:  
 
@@ -95,7 +90,26 @@ const jsonSchema = parse(joiSchema)
 // const openApiSchema = parse(joiSchema, 'open-api')
 ```
 
-### Joi to OpenAPI
+## Features
+
+### Special Joi Operator Support
+
+* [Logical Relation Operator](./docs/logical_rel_support.md)
+
+### Named Link
+
+Supports named link for schema reuse, such as `.link('#person')`.  **For `open-api` conversion**, as the shared schemas are located in `#/components/schemas` which is not self-contained, the conversion result contains an **extra `schemas`** field so that you can extract it when required.
+
+### Conditional Expression
+
+Starting from Draft 7, JSON Specification supports `If-Then-Else` style expression.  Before that, we can also use something called [Implication](http://json-schema.org/understanding-json-schema/reference/conditionals.html#implication) using Schema Composition Approach to simulate that.
+
+By default, the `If-Then-Else` approach is used if the output spec supports it.  However, if the joi conditional expression (`alternatives` or `when`) is annotated using Meta `.meta({ 'if-style': true })`, the JSON schema conversion will use the Composition approach using `allOf` and/or `anyOf` instead.
+
+**Limitation**: Currently, if the joi condition definition is referring to another field, the `If-Then-Else` style output is not supported.  Instead, it simply uses the `anyOf` composing the `then` and `otherwise` on the defined field.
+
+
+## YAML File Generation
 
 Most Joi specifications result in the expected OpenAPI schema. 
 
@@ -196,7 +210,7 @@ properties:
     properties:
       key:
         type: string
-    additionalProperties: true    
+    additionalProperties: true
 additionalProperties: false
 ```
 
@@ -242,10 +256,6 @@ properties:
 additionalProperties: true
 ```
 
-## Special Joi Operator Support
-
-* [Logical Relation Operator](./docs/logical_rel_support.md)
-
 ## 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.
 
@@ -265,7 +275,7 @@ const logicalOpParser: Joi2Json.LogicalOpParserOpts = {
 };
 
 parse(joi.string()); // Default call
-parse(joi.string(), 'json', {}, false); // Completely disable Logical Relation Operator
+parse(joi.string(), 'json', {}, { logicalOpParser: false }); // Completely disable Logical Relation Operator
 parse(joi.string(), 'open-api', {}, { logicalOpParser }); // Partially override Logical Relation Operator
 ```
 
@@ -273,19 +283,50 @@ parse(joi.string(), 'open-api', {}, { logicalOpParser }); // Partially override
 
 >npm run test
 
-You can optionally set below environment variables:
+### Categories of Test Cases
 
-* `CASE_PATTERN=joi-obj-17` to control which version of joi obj to test
+* JOI Standard Representation Conversion
 
-## Known Limitation
+`fixtures-conversion` folder stores each JOI version's supported keyword for different data types.
+In case any data type or keyword is not supported in historical JOI version, we can just create customized file to override the `base` version, such as `v15/link.js`.
 
-* For `object.pattern` usage in Joi, `pattern` parameter can only be a regular expression now as I cannot convert Joi object to regex yet.
+Standard converted results are stored in `outputs-conversion` folder.
+
+`test/conversion.spec.js` Test Spec handles all supported JOI versions' conversion verificaiton.
+
+* JSON output format Conversion
+
+`outputs-parsers` folder stores different output formats base on the JOI Standard Representation in `outputs-conversion` folder.
+The Test Spec under `test/parser/` are responsible for these area.
+
+* JSON schema (Draft 07) Validity Unit Test
 
-## Updates
+For special **Logical Relation Operator** and **Conditional Expression**, some Unit Tests are created to verify the JOI Spec and corresponding JSON Spec are valid of the same verification intention.
 
-**Version 2.3.0**
 
-* Supports named link for schema resuse, such as `.link('#person')`.  **For `open-api` conversion**, as the shared schemas are located in `#/components/schemas` which is not self-contained, the conversion result contains an **extra `schemas`** field so that you can extract it when required.
+### Test Debug Approach
+
+When running `conversion.spec.js`, below environment variables can be set:
+
+* `TEST_CONVERTOR`: control which version of joi to test.
+  Example: `TEST_CONVERTOR=v17`
+* `TEST_CASE`: control which test cases to verify.  Name of the test cases is the key of the return object in `fixtures-conversion`.
+  Example: `TEST_CASE=conditional,match_all` verifies the case in `alternatives.js`
+* `TEST_UPDATE_CONVERSION_BASELINE`: control whether writes the baseline file generated from the latest-version convertor (Currently `v17`).
+  It is activated when setting to `true`.
+
+When runninng Test Spec under `test/parser`, below environment variables can be set:
+
+* `TEST_CASE`: control which test cases to verify.
+  For example, when running `json.spec.js`, and set `TEST_CASE=conditional,match_all`, it verifies the corresponding JSON files in `outputs-parsers/json/alternatives`.
+* `TEST_UPDATE_PARSER_BASELINE`: control whether writes the baseline file for the corresponding parser.
+  It is activated when setting to `true`.  For example, when running `json.spec.js`, it writes the baseline files under `outputs-parsers/json`.
+
+
+## Known Limitation
+
+* For `object.pattern` usage in Joi, `pattern` parameter can only be a regular expression now as I cannot convert Joi object to regex yet.
+* `If-Then-Else` style output is not applicable for the condition referring to the other field.
 
 ## License
 

package/lib/convertors/v12.js

@@ -12,6 +12,16 @@ class JoiSpecConvertor {
   }
 
   _convertObject(joiObj) {
+    _.each(joiObj.rules, (rule, _idx) => {
+      const name = rule.name
+      if (['min', 'max', 'length'].includes(name)) {
+        rule.args = {
+          limit: rule.arg
+        }
+      }
+      delete rule.arg
+    })
+
     if (joiObj.children) {
       joiObj.keys = joiObj.children
       delete joiObj.children
@@ -30,6 +40,9 @@ class JoiSpecConvertor {
 
   _convertDependencies(joiObj) {
     _.each(joiObj.dependencies, (dependency) => {
+      if (dependency.key === null) {
+        delete dependency.key
+      }
       if (dependency.type) {
         dependency.rel = dependency.type
         delete dependency.type
@@ -48,61 +61,92 @@ class JoiSpecConvertor {
   }
 
   _convertAlternatives(joiObj) {
-    let isWhenCase = false
-    if (joiObj.alternatives.length === 1) {
-      const condition = joiObj.alternatives[0]
-      isWhenCase = !!condition.then || !!condition.otherwise
-    }
+    // backup alternatives setting
+    const alternatives = joiObj.alternatives
+    let fieldName = 'matches'
 
-    if (isWhenCase) {
-      // when case
-      joiObj.type = 'any'
-      joiObj.whens = joiObj.alternatives
+    if (joiObj.base) {
+      // When case is based on one schema type
+      fieldName = 'whens'
 
-      if (joiObj.flags.presence === 'ignore') {
-        // FIXME: Not sure when this flag is set.
+      const baseType = joiObj.base
+      delete joiObj.base
+      delete joiObj.alternatives
+      if (joiObj.flags && joiObj.flags.presence) {
         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
+      this.toBaseSpec(baseType)
+
+      _.merge(joiObj, baseType)
+    }
+
+    // Convert alternatives
+    joiObj[fieldName] = _.map(alternatives, (alternative) => {
+      if (alternative.peek || alternative.ref) {
+        if (alternative.peek) {
+          alternative.is = alternative.peek
+          delete alternative.peek
         }
-        return value
-      })
 
-      delete joiObj.alternatives
-      delete joiObj.base
-    } else {
-      joiObj.matches = _.map(joiObj.alternatives, (alternative) => {
+        return _.mapValues(alternative, (value, condition) => {
+          switch (condition) {
+            case 'is':
+              this.toBaseSpec(value)
+              if (alternative.ref) {
+                // alternative field reference case
+                value.type = 'any'
+                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
+        })
+      } else {
         return {
           schema: this.toBaseSpec(alternative)
         }
-      })
-      delete joiObj.alternatives
-    }
+      }
+    })
+
+    // FIXME: Joi seems merging the `is` to `then` schema
+    _.forEach(joiObj[fieldName], (alternative) => {
+      if (alternative.is && alternative.then) {
+        if (alternative.is.type === 'object') {
+          const isKeys = Object.keys(alternative.is.keys)
+          _.forEach(isKeys, (key) => {
+            delete alternative.then.keys[key]
+          })
+        }
+      }
+    })
+
+    delete joiObj.alternatives
+  }
+
+  _convertBinary(joiObj) {
+    _.each(joiObj.rules, (rule, _idx) => {
+      const name = rule.name
+      if (['min', 'max', 'length'].includes(name)) {
+        rule.args = {
+          limit: rule.arg
+        }
+      }
+      delete rule.arg
+    })
   }
 
   _convertString(joiObj) {
@@ -162,6 +206,18 @@ class JoiSpecConvertor {
   }
 
   _convertBoolean(joiObj) {
+    if (_.isArray(joiObj.truthy)) {
+      _.remove(joiObj.truthy, (i) => i === true)
+      if (joiObj.truthy.length === 0) {
+        delete joiObj.truthy
+      }
+    }
+    if (_.isArray(joiObj.falsy)) {
+      _.remove(joiObj.falsy, (i) => i === false)
+      if (joiObj.falsy.length === 0) {
+        delete joiObj.falsy
+      }
+    }
     if (joiObj.flags.insensitive === false) {
       joiObj.flags.sensitive = true
     }
@@ -180,6 +236,12 @@ class JoiSpecConvertor {
           limit: rule.arg
         }
       }
+      if (name === 'has') {
+        this.toBaseSpec(rule.arg)
+        rule.args = {
+          schema: rule.arg
+        }
+      }
       delete rule.arg
     })
 
@@ -196,12 +258,12 @@ class JoiSpecConvertor {
 
     if (joiObj.flags.allowOnly) {
       joiObj.flags.only = joiObj.flags.allowOnly
-      delete joiObj.flags.allowOnly
     }
+    delete joiObj.flags.allowOnly
     if (joiObj.flags.allowUnknown) {
       joiObj.flags.unknown = joiObj.flags.allowUnknown
-      delete joiObj.flags.allowUnknown
     }
+    delete joiObj.flags.allowUnknown
     if (joiObj.description) {
       joiObj.flags.description = joiObj.description
       delete joiObj.description
@@ -218,6 +280,13 @@ class JoiSpecConvertor {
       joiObj.metas = joiObj.meta
       delete joiObj.meta
     }
+    if (joiObj.invalids) {
+      // FIXME Looks like before v16, joi spec default add [''] for string and [Infinity,-Infinity] for number
+      if (!(joiObj.invalids.length === 1 && joiObj.invalids[0] === '') &&
+        !(joiObj.invalids.length === 2 && joiObj.invalids[0] === Infinity && joiObj.invalids[1] === -Infinity)) {
+        joiObj.invalid = joiObj.invalids
+      }
+    }
     delete joiObj.invalids
 
     this._convertExamples(joiObj)
@@ -232,6 +301,9 @@ class JoiSpecConvertor {
       case 'alternatives':
         this._convertAlternatives(joiObj)
         break
+      case 'binary':
+        this._convertBinary(joiObj)
+        break
       case 'string':
         this._convertString(joiObj)
         break

package/lib/convertors/v14.js

@@ -10,6 +10,9 @@ class JoiSpecConvertor extends BaseConverter {
       const example = joiObj.examples[0]
       joiObj.examples = [example.value]
     }
+    if (joiObj.examples && joiObj.allow && joiObj.flags && joiObj.flags.only) {
+      joiObj.examples = joiObj.allow
+    }
   }
 
   _convertNumber(joiObj) {

package/lib/convertors/v16.js

@@ -18,6 +18,8 @@ class JoiSpecConvertor extends BaseConverter {
 
   _convertAlternatives(_joiObj) { }
 
+  _convertBinary(_joiObj) { }
+
   _convertString(_joiObj) { }
 
   _convertNumber(_joiObj) { }

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

@@ -15,6 +15,10 @@ class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
     }, opts))
   }
 
+  _isIfThenElseSupported() {
+    return false
+  }
+
   _setNumberFieldProperties(fieldSchema, fieldDefn) {
     super._setNumberFieldProperties(fieldSchema, fieldDefn)
 
@@ -29,6 +33,29 @@ class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
   _getLocalSchemaBasePath() {
     return '#/definitions'
   }
+
+  _setArrayFieldProperties(fieldSchema, fieldDefn, definitions, level) {
+    super._setArrayFieldProperties(fieldSchema, fieldDefn, definitions, level)
+
+    delete fieldSchema.contains
+  }
+
+  _setConst(fieldSchema, fieldDefn) {
+    super._setConst(fieldSchema, fieldDefn)
+
+    if (typeof fieldSchema.const !== 'undefined') {
+      if (fieldSchema.const === null) {
+        fieldSchema.type = 'null'
+      } else if (_.isArray(fieldSchema.const)) {
+        fieldSchema.type = 'array'
+      } else {
+        // boolean / number / string / object
+        fieldSchema.type = typeof fieldSchema.const
+      }
+      fieldSchema.enum = [fieldSchema.const]
+      delete fieldSchema.const
+    }
+  }
 }
 
 module.exports = JoiJsonDraftSchemaParser

package/lib/parsers/json-draft-2019-09.js

@@ -8,7 +8,7 @@ class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
     if (!_.isEmpty(joiSpec.metas)) {
       _.each(joiSpec.metas, meta => {
         _.each(meta, (value, key) => {
-          if (key === 'deprecated') {
+          if (key === 'deprecated' || key === 'readOnly' || key === 'writeOnly') {
             schema[key] = value
           }
         })

package/lib/parsers/json.js

@@ -111,10 +111,12 @@ class JoiJsonSchemaParser {
     this._setArrayFieldProperties(schema, joiSpec, definitions, level)
     this._setObjectProperties(schema, joiSpec, definitions, level)
     this._setAlternativesProperties(schema, joiSpec, definitions, level)
-    this._setAnyProperties(schema, joiSpec, definitions, level)
-    this._addNullTypeIfNullable(schema, joiSpec)
+    this._setConditionProperties(schema, joiSpec, definitions, level, 'whens')
     this._setMetaProperties(schema, joiSpec)
     this._setLinkFieldProperties(schema, joiSpec)
+    this._setConst(schema, joiSpec)
+    this._setAnyProperties(schema, joiSpec, definitions, level)
+    this._addNullTypeIfNullable(schema, joiSpec)
 
     if (!_.isEmpty(joiSpec.shared)) {
       this.parse(joiSpec.shared[0], definitions, level)
@@ -134,6 +136,10 @@ class JoiJsonSchemaParser {
     return schema
   }
 
+  _isIfThenElseSupported() {
+    return true
+  }
+
   _getChildrenFieldName() {
     return 'keys'
   }
@@ -173,9 +179,21 @@ class JoiJsonSchemaParser {
 
   _addNullTypeIfNullable(fieldSchema, fieldDefn) {
     // This should always be the last call in parse
+    if (fieldSchema.const === null) {
+      return
+    }
+
     const enums = _.get(fieldDefn, this.enumFieldName)
     if (Array.isArray(enums) && enums.includes(null)) {
-      fieldSchema.type = [fieldSchema.type, 'null']
+      if (Array.isArray(fieldSchema.type)) {
+        if (!fieldSchema.type.includes('null')) {
+          fieldSchema.type.push('null')
+        }
+      } else if (fieldSchema.type) {
+        fieldSchema.type = [fieldSchema.type, 'null']
+      } else {
+        fieldSchema.type = 'null'
+      }
     }
   }
 
@@ -200,13 +218,6 @@ class JoiJsonSchemaParser {
     return _.get(fieldDefn, 'flags.default')
   }
 
-  _getConst(fieldDefn) {
-    const enumList = fieldDefn[this.enumFieldName]
-    if (fieldDefn.flags && fieldDefn.flags.only && _.size(enumList) === 1) {
-      return enumList[0]
-    }
-  }
-
   _getEnum(fieldDefn) {
     const enumList = fieldDefn[this.enumFieldName]
     const filteredEnumList = enumList ? _.filter(enumList, e => !isJoiOverride(e)) : enumList
@@ -234,8 +245,13 @@ class JoiJsonSchemaParser {
     this._setIfNotEmpty(fieldSchema, 'examples', this._getFieldExample(fieldDefn))
     this._setIfNotEmpty(fieldSchema, 'description', this._getFieldDescription(fieldDefn))
     this._setIfNotEmpty(fieldSchema, 'default', this._getDefaultValue(fieldDefn))
-    this._setIfNotEmpty(fieldSchema, 'const', this._getConst(fieldDefn))
     this._setIfNotEmpty(fieldSchema, 'enum', this._getEnum(fieldDefn))
+    if (fieldDefn.invalid && fieldDefn.invalid.length > 0) {
+      fieldSchema.not = {
+        type: fieldSchema.type,
+        enum: fieldDefn.invalid
+      }
+    }
   }
 
   _setBinaryFieldProperties(fieldSchema, fieldDefn) {
@@ -480,6 +496,9 @@ class JoiJsonSchemaParser {
         case 'unique':
           fieldSchema.uniqueItems = true
           break
+        case 'has':
+          fieldSchema.contains = this.parse(value.schema, definitions, level + 1)
+          break
         default:
           break
       }
@@ -518,61 +537,192 @@ class JoiJsonSchemaParser {
   }
 
   _setAlternativesProperties(schema, joiSpec, definitions, level) {
-    if (schema.type !== 'alternatives') {
+    if (schema.type !== 'alternatives' || joiSpec.matches.length === 0) {
       return
     }
 
-    if (joiSpec.matches.length === 1) {
-      const match = joiSpec.matches[0]
-      if (match.switch) {
-        schema.oneOf = _.map(match.switch, (condition) => {
-          return this.parse(condition.then || condition.otherwise, definitions, level + 1)
-        })
-      } else if (match.then || match.otherwise) {
-        schema.oneOf = []
-        if (match.then) schema.oneOf.push(this.parse(match.then, definitions, level + 1))
-        if (match.otherwise) schema.oneOf.push(this.parse(match.otherwise, definitions, level + 1))
+    if (joiSpec.matches[0].schema) {
+      // try style
+      let mode = 'anyOf'
+      if (joiSpec.flags && joiSpec.flags.match === 'one') {
+        mode = 'oneOf'
+      } else if (joiSpec.flags && joiSpec.flags.match === 'all') {
+        mode = 'allOf'
       }
-    } else {
-      schema.oneOf = _.map(joiSpec.matches, (match) => {
+
+      schema[mode] = _.map(joiSpec.matches, (match) => {
         return this.parse(match.schema, definitions, level + 1)
       })
+
+      if (schema[mode].length === 1) {
+        _.merge(schema, schema[mode][0])
+        delete schema[mode]
+      }
+    } else {
+      this._setConditionProperties(schema, joiSpec, definitions, level, 'matches', 'anyOf')
     }
 
-    delete schema.type
+    if (schema.type === 'alternatives') {
+      delete schema.type
+    }
   }
 
-  _setAnyProperties(schema, joiSpec, definitions, level) {
-    if (schema.type !== 'any') {
+  _setConditionProperties(schema, joiSpec, definitions, level, conditionFieldName, logicKeyword = 'allOf') {
+    if (!joiSpec[conditionFieldName] || joiSpec[conditionFieldName].length === 0) {
       return
     }
 
-    if (joiSpec.whens) {
-      schema.oneOf = []
+    let ifThenStyle = this._isIfThenElseSupported()
+    const styleSetting = _.remove(joiSpec.metas, (meta) => {
+      return typeof meta['if-style'] !== undefined
+    })
 
-      const condition = joiSpec.whens[0]
+    if (ifThenStyle && styleSetting.length > 0 && styleSetting[0]['if-style'] === false) {
+      ifThenStyle = false
+    }
 
-      if (condition.switch) {
-        for (const switchCondition of condition.switch) {
-          if (switchCondition.then) {
-            schema.oneOf.push(this.parse(switchCondition.then, definitions, level + 1))
-          }
+    if (joiSpec[conditionFieldName].length > 1) {
+      // Multiple case
+      schema[logicKeyword] = _.map(joiSpec[conditionFieldName], (condition) => {
+        return this._setConditionSchema(ifThenStyle, {}, condition, definitions, level + 1)
+      })
+    } else {
+      this._setConditionSchema(ifThenStyle, schema, joiSpec[conditionFieldName][0], definitions, level + 1)
+    }
+  }
 
-          if (switchCondition.otherwise) {
-            schema.oneOf.push(this.parse(switchCondition.otherwise, definitions, level + 1))
-          }
+  _setConditionSchema(ifThenStyle, schema, conditionJoiSpec, definitions, level) {
+    // When "if" is not present, both "then" and "else" MUST be entirely ignored.
+    // There must be either "is" or "switch"
+    if (!conditionJoiSpec.is && !conditionJoiSpec.switch) {
+      return
+    }
+
+    if (conditionJoiSpec.switch) {
+      this._parseSwitchCondition(ifThenStyle, schema, conditionJoiSpec, definitions, level)
+    } else {
+      if (ifThenStyle) {
+        this._parseIfThenElseCondition(schema, conditionJoiSpec, definitions, level)
+      } else {
+        this._setConditionCompositionStyle(schema, conditionJoiSpec, definitions, level)
+      }
+    }
+
+    return schema
+  }
+
+  _parseIfThenElseCondition(schema, conditionSpec, definitions, level) {
+    if (conditionSpec.ref) {
+      // Currently, if there is reference, if-then-else style is not supported
+      // To use it, the condition must be defined in parent level using schema-style is
+      return this._setConditionCompositionStyle(schema, conditionSpec, definitions, level)
+    }
+
+    schema.if = this.parse(conditionSpec.is, definitions, level)
+
+    if (conditionSpec.then) {
+      schema.then = this.parse(conditionSpec.then, definitions, level)
+    }
+    if (conditionSpec.otherwise) {
+      schema.else = this.parse(conditionSpec.otherwise, definitions, level)
+    }
+    return schema
+  }
+
+  _parseSwitchCondition(ifThenStyle, schema, condition, definitions, level) {
+    // Switch cannot be used if the joi condition is a schema
+    // Hence, condition.ref should always exists
+    const anyOf = []
+    for (const switchCondition of condition.switch) {
+      if (ifThenStyle && !condition.ref) {
+        const innerSchema = this._parseIfThenElseCondition(
+          {}, switchCondition, definitions, level + 1)
+
+        anyOf.push(innerSchema)
+      } else {
+        if (switchCondition.then) {
+          anyOf.push(this.parse(switchCondition.then, definitions, level + 1))
+        }
+
+        if (switchCondition.otherwise) {
+          anyOf.push(this.parse(switchCondition.otherwise, definitions, level + 1))
         }
       }
+    }
 
+    if (anyOf.length > 1) {
+      schema.anyOf = anyOf
+    } else {
+      _.merge(schema, oneOf[0])
+    }
+  }
+
+  _setConditionCompositionStyle(schema, condition, definitions, level) {
+    if (condition.ref) {
+      // If the condition is refering to other field, cannot use the `is` condition for composition
+      // Simple choise between then / otherwise
+      const oneOf = schema.oneOf || []
       if (condition.then) {
-        schema.oneOf.push(this.parse(condition.then, definitions, level + 1))
+        oneOf.push(this.parse(condition.then, definitions, level + 1))
       }
-
       if (condition.otherwise) {
-        schema.oneOf.push(this.parse(condition.otherwise, definitions, level + 1))
+        oneOf.push(this.parse(condition.otherwise, definitions, level + 1))
       }
+      if (oneOf.length > 1) {
+        schema.oneOf = oneOf
+      } else {
+        _.merge(schema, oneOf[0])
+      }
+    } else {
+      // Before Draft 7, you can express an “if-then” conditional using the Schema Composition keywords
+      // and a boolean algebra concept called “implication”.
+      // A -> B(pronounced, A implies B) means that if A is true, then B must also be true.
+      // It can be expressed as !A || B
+
+      // Variations of implication can express the same things you can express with the if/then/else keywords.
+      // if/then can be expressed as A -> B, if/else can be expressed as !A -> B,
+      // and if/then/else can be expressed as A -> B AND !A -> C
+      if (condition.is && condition.then && condition.otherwise) {
+        schema.allOf = [
+          {
+            anyOf: [
+              {
+                not: this.parse(condition.is, definitions, level + 1)
+              },
+              this.parse(condition.then, definitions, level + 1)
+            ]
+          },
+          {
+            anyOf: [
+              this.parse(condition.is, definitions, level + 1),
+              this.parse(condition.otherwise, definitions, level + 1)
+            ]
+          }
+        ]
+      } else if (condition.is && condition.then) {
+        schema.anyOf = [
+          {
+            not: this.parse(condition.is, definitions, level + 1)
+          },
+          this.parse(condition.then, definitions, level + 1)
+        ]
+      }
+    }
 
+    return schema
+  }
+
+  _setConst(schema, fieldDefn) {
+    const enumList = fieldDefn[this.enumFieldName]
+    const filteredEnumList = enumList ? _.filter(enumList, e => !isJoiOverride(e)) : enumList
+    if (fieldDefn.flags && fieldDefn.flags.only && _.size(filteredEnumList) === 1) {
+      schema.const = filteredEnumList[0]
       delete schema.type
+    }
+  }
+
+  _setAnyProperties(schema) {
+    if (schema.type !== 'any') {
       return
     }
 

package/lib/parsers/open-api.js

@@ -6,7 +6,8 @@ class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
     super(_.merge({
       logicalOpParser: {
         xor: null,
-        with: null
+        with: null,
+        without: null
       }
     }, opts))
   }
@@ -69,6 +70,10 @@ class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
     return schema
   }
 
+  _isIfThenElseSupported() {
+    return false
+  }
+
   _getLocalSchemaBasePath() {
     return '#/components/schemas'
   }
@@ -82,9 +87,41 @@ class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
   }
 
   _addNullTypeIfNullable(fieldSchema, fieldDefn) {
-    const enums = _.get(fieldDefn, this.enumFieldName)
-    if (Array.isArray(enums) && enums.includes(null)) {
+    super._addNullTypeIfNullable(fieldSchema, fieldDefn)
+
+    if (fieldSchema.type === 'null') {
+      delete fieldSchema.type
+      fieldSchema.nullable = true
+    } else if (_.isArray(fieldSchema.type) && fieldSchema.type.includes('null')) {
+      _.remove(fieldSchema.type, (i) => {
+        return i === 'null'
+      })
       fieldSchema.nullable = true
+
+      if (fieldSchema.type.length === 1) {
+        fieldSchema.type = fieldSchema.type[0]
+      }
+    }
+
+    if (_.isArray(fieldSchema.type)) {
+      // anyOf might exist for When / Alternative case
+      fieldSchema.anyOf = fieldSchema.anyOf || []
+
+      _.forEach(fieldSchema.type, (t) => {
+        const typeExisted = _.some(fieldSchema.anyOf, (condition) => {
+          return condition.type === t
+        })
+
+        if (!typeExisted) {
+          const def = { type: t }
+          if (t === 'array') {
+            def.items = {}
+          }
+          fieldSchema.anyOf.push(def)
+        }
+      })
+
+      delete fieldSchema.type
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joi-to-json",
-  "version": "3.1.2",
+  "version": "4.0.0",
   "description": "joi to JSON / OpenAPI Schema Converter",
   "main": "index.js",
   "repository": {
@@ -28,16 +28,17 @@
     "semver-compare": "^1.0.0"
   },
   "devDependencies": {
+    "@jest/transform": "^29.6.2",
     "ajv": "^8.12.0",
     "ajv-draft-04": "^1.0.0",
-    "eslint": "^8.31.0",
-    "jest": "^29.3.1",
+    "eslint": "^8.47.0",
+    "jest": "^29.6.2",
     "joi-12": "npm:@commercial/joi@^12.1.0",
     "joi-13": "npm:joi@^13.7.0",
     "joi-14": "npm:joi@^14.3.1",
     "joi-15": "npm:@hapi/joi@^15.1.1",
     "joi-16": "npm:@hapi/joi@^16.1.8",
-    "joi-17": "npm:joi@^17.6.0"
+    "joi-17": "npm:joi@^17.9.2"
   },
   "types": "index.d.ts",
   "files": [

package/CHANGELOG.md

@@ -1,11 +0,0 @@
-### 3.1.1
-
-- Fix Typescript definition.
-
-### 3.1.0
-
-- Add support for relation operator `with` and `without`.
-
-### 3.0.0
-
-- [BREAKING] Default enable feature: relation operator `and`, `or`, `nand`, `xor`, `oxor`.