joi-to-json 5.0.0 → 5.0.2

package/docs/logical_rel_support.md

@@ -1,241 +1,241 @@
-## Logical Relation
-
-There are some logical relation operators in Joi:
-
-* `and`
-* `nand`
-* `or`
-* `xor`
-* `oxor` (After Joi v14)
-* `with`
-* `without`
-
-For different operator, I have managed to describe them in JSON schema as below for different cases.
-Some named as `xxxGeneral` means it should be supported since JSON Draft 4.
-Some named as `xxxDraft7` means it is using some features until JSON Draft 7.
-
-Hence, if you are converting the Joi to Draft 4 or OpenAPI, the `xor` will be ignored.
-
-### Usage
-
-By default, this feature is enabled.
-It can be disabled completely by passing option `{ logicalOpParser: false }` to `parse` API:
-
-`parse(joiObj, 'json', {}, { logicalOpParser: false })`
-
-It's also possible to disable one particular operator or use your own convertor if you come up with a more suitable JSON schema representation by passing options like `{ logicalOpParser: { xor: convertorFun, oxor: null } }`.
-
-The signature of the `convertorFun` is `function (schema, dependency)`.  For example, the built-in `or` convertor function is:
-
-```javascript
-function (schema, dependency) {
-  schema.anyOf = _.map(dependency.peers, (peer) => {
-    return { required: [peer] }
-  })
-}
-```
-
-### OR
-
-```javascript
-// At least one of a or b or c exists.
-// Failed on { d: 1 }
-const orJoi = joi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).or('a', 'b', 'c');
-
-const orSchemaGeneral = {
-  type: 'object',
-  anyOf: [
-    { required: ['a'] }, { required: ['b'] }, { required: ['c'] }
-  ],
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-}
-```
-
-### AND
-
-```javascript
-// Either a, b, and c All NOT exists, or all of them exists
-// Failed on { a: 'hi', b: 1 }
-const andJoi = joi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).and('a', 'b', 'c');
-
-const andSchemaGeneral = {
-  type: 'object',
-  oneOf: [
-    {
-      allOf: [
-        {
-          not: { required: ['a'] }
-        },
-        {
-          not: { required: ['b'] }
-        },
-        {
-          not: { required: ['c'] }
-        }
-      ]
-    },
-    { required: ['a', 'b', 'c'] }
-  ],
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
-
-### NAND
-
-```javascript
-// a, b, and c cannot all exist at the same time
-// Failed on { a: 'hi', b: 1, c: true }
-const nandJoi = joi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).nand('a', 'b', 'c');
-
-const nandSchemaGeneral = {
-  type: 'object',
-  not: { required: ['a', 'b', 'c'] },
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
-
-### XOR
-
-```javascript
-// Only one of a, b and c can and must exist
-// Failed on { d: 1 } or { a: 'hi', b: 1 }
-const xorJoi = joi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).xor('a', 'b', 'c');
-
-const xorSchemaDraft7 = {
-  type: 'object',
-  if: { propertyNames: { enum: ['a', 'b', 'c'] }, minProperties: 2 },
-  then: false,
-  else: {
-    oneOf: [
-      {
-        required: ['a']
-      },
-      {
-        required: ['b']
-      },
-      {
-        required: ['c']
-      }
-    ]
-  },
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
-
-### OXOR
-
-```javascript
-// Only one of a, b and c can exist but none is required
-// Failed on { a: 'hi', b: 1 }
-const oxorJoi = joi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).oxor('a', 'b', 'c');
-
-const oxorSchemaGeneral = {
-  type: 'object',
-  oneOf: [
-    { required: ['a'] },
-    { required: ['b'] },
-    { required: ['c'] },
-    {
-      not: {
-        oneOf: [
-          { required: ['a'] },
-          { required: ['b'] },
-          { required: ['c'] },
-          { required: ['a', 'b'] },
-          { required: ['a', 'c'] },
-          { required: ['b', 'c'] } // Combination up to 2 elements
-        ]
-      }
-    }
-  ],
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
-
-### WITH
-
-```javascript
-// With d exists, both a and b must exist
-// Failed on { d: 1, a: '' }
-const withJoi = jjoi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).with('c', ['a']).with('d', ['a', 'b']);
-
-const withSchemaBeforeBefore2019 = {
-  type: 'object',
-  dependencies: {
-    c: ['a'],
-    d: ['a', 'b']
-  },
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-
-const withSchemaBeforeDraft2019 = {
-  type: 'object',
-  dependentRequired: {
-    c: ['a'],
-    d: ['a', 'b']
-  },
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
-
-### WITHOUT
-
-```javascript
-// With a exists, either b or c must not exist
-// Failed on { a: '', b: 1 }
-const withoutJoi = jjoi.object({
-  a: joi.string(),
-  b: joi.number(),
-  c: joi.boolean(),
-  d: joi.number()
-}).without('a', ['b', 'c']);
-
-const withoutSchemaDraft7 = {
-  type: 'object',
-  if: { required: ['a'] },
-  then: {
-    not: {
-      anyOf: [{ required: ['b'] }, { required: ['c'] }]
-    }
-  },
-  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
-  additionalProperties: false
-};
-```
+## Logical Relation
+
+There are some logical relation operators in Joi:
+
+* `and`
+* `nand`
+* `or`
+* `xor`
+* `oxor` (After Joi v14)
+* `with`
+* `without`
+
+For different operator, I have managed to describe them in JSON schema as below for different cases.
+Some named as `xxxGeneral` means it should be supported since JSON Draft 4.
+Some named as `xxxDraft7` means it is using some features until JSON Draft 7.
+
+Hence, if you are converting the Joi to Draft 4 or OpenAPI, the `xor` will be ignored.
+
+### Usage
+
+By default, this feature is enabled.
+It can be disabled completely by passing option `{ logicalOpParser: false }` to `parse` API:
+
+`parse(joiObj, 'json', {}, { logicalOpParser: false })`
+
+It's also possible to disable one particular operator or use your own convertor if you come up with a more suitable JSON schema representation by passing options like `{ logicalOpParser: { xor: convertorFun, oxor: null } }`.
+
+The signature of the `convertorFun` is `function (schema, dependency)`.  For example, the built-in `or` convertor function is:
+
+```javascript
+function (schema, dependency) {
+  schema.anyOf = _.map(dependency.peers, (peer) => {
+    return { required: [peer] }
+  })
+}
+```
+
+### OR
+
+```javascript
+// At least one of a or b or c exists.
+// Failed on { d: 1 }
+const orJoi = joi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).or('a', 'b', 'c');
+
+const orSchemaGeneral = {
+  type: 'object',
+  anyOf: [
+    { required: ['a'] }, { required: ['b'] }, { required: ['c'] }
+  ],
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+}
+```
+
+### AND
+
+```javascript
+// Either a, b, and c All NOT exists, or all of them exists
+// Failed on { a: 'hi', b: 1 }
+const andJoi = joi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).and('a', 'b', 'c');
+
+const andSchemaGeneral = {
+  type: 'object',
+  oneOf: [
+    {
+      allOf: [
+        {
+          not: { required: ['a'] }
+        },
+        {
+          not: { required: ['b'] }
+        },
+        {
+          not: { required: ['c'] }
+        }
+      ]
+    },
+    { required: ['a', 'b', 'c'] }
+  ],
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```
+
+### NAND
+
+```javascript
+// a, b, and c cannot all exist at the same time
+// Failed on { a: 'hi', b: 1, c: true }
+const nandJoi = joi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).nand('a', 'b', 'c');
+
+const nandSchemaGeneral = {
+  type: 'object',
+  not: { required: ['a', 'b', 'c'] },
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```
+
+### XOR
+
+```javascript
+// Only one of a, b and c can and must exist
+// Failed on { d: 1 } or { a: 'hi', b: 1 }
+const xorJoi = joi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).xor('a', 'b', 'c');
+
+const xorSchemaDraft7 = {
+  type: 'object',
+  if: { propertyNames: { enum: ['a', 'b', 'c'] }, minProperties: 2 },
+  then: false,
+  else: {
+    oneOf: [
+      {
+        required: ['a']
+      },
+      {
+        required: ['b']
+      },
+      {
+        required: ['c']
+      }
+    ]
+  },
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```
+
+### OXOR
+
+```javascript
+// Only one of a, b and c can exist but none is required
+// Failed on { a: 'hi', b: 1 }
+const oxorJoi = joi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).oxor('a', 'b', 'c');
+
+const oxorSchemaGeneral = {
+  type: 'object',
+  oneOf: [
+    { required: ['a'] },
+    { required: ['b'] },
+    { required: ['c'] },
+    {
+      not: {
+        oneOf: [
+          { required: ['a'] },
+          { required: ['b'] },
+          { required: ['c'] },
+          { required: ['a', 'b'] },
+          { required: ['a', 'c'] },
+          { required: ['b', 'c'] } // Combination up to 2 elements
+        ]
+      }
+    }
+  ],
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```
+
+### WITH
+
+```javascript
+// With d exists, both a and b must exist
+// Failed on { d: 1, a: '' }
+const withJoi = jjoi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).with('c', ['a']).with('d', ['a', 'b']);
+
+const withSchemaBeforeBefore2019 = {
+  type: 'object',
+  dependencies: {
+    c: ['a'],
+    d: ['a', 'b']
+  },
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+
+const withSchemaBeforeDraft2019 = {
+  type: 'object',
+  dependentRequired: {
+    c: ['a'],
+    d: ['a', 'b']
+  },
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```
+
+### WITHOUT
+
+```javascript
+// With a exists, either b or c must not exist
+// Failed on { a: '', b: 1 }
+const withoutJoi = jjoi.object({
+  a: joi.string(),
+  b: joi.number(),
+  c: joi.boolean(),
+  d: joi.number()
+}).without('a', ['b', 'c']);
+
+const withoutSchemaDraft7 = {
+  type: 'object',
+  if: { required: ['a'] },
+  then: {
+    not: {
+      anyOf: [{ required: ['b'] }, { required: ['c'] }]
+    }
+  },
+  properties: { a: { type: 'string' }, b: { type: 'number' }, c: { type: 'boolean' }, d: { type: 'number' } },
+  additionalProperties: false
+};
+```

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

@@ -1,74 +1,74 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json')
-
-class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
-  constructor(opts = {}) {
-    super(_.merge({
-      $schema: 'http://json-schema.org/draft-04/schema#',
-      logicalOpParser: {
-        xor: null,
-        with: function (schema, dependency) {
-          schema.dependencies = schema.dependencies || {}
-          schema.dependencies[dependency.key] = dependency.peers
-        },
-        without: null
-      }
-    }, opts))
-  }
-
-  _isIfThenElseSupported() {
-    return false
-  }
-
-  _setNumberFieldProperties(fieldSchema, fieldDefn) {
-    super._setNumberFieldProperties(fieldSchema, fieldDefn)
-
-    if (typeof fieldSchema.exclusiveMinimum !== 'undefined') {
-      fieldSchema.minimum = fieldSchema.exclusiveMinimum
-      fieldSchema.exclusiveMinimum = true
-    }
-    if (typeof fieldSchema.exclusiveMaximum !== 'undefined') {
-      fieldSchema.maximum = fieldSchema.exclusiveMaximum
-      fieldSchema.exclusiveMaximum = true
-    }
-
-    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'
-  }
-
-  _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
-        if (fieldSchema.type === 'number' && Number.isInteger(fieldSchema.const)) {
-          fieldSchema.type = 'integer'
-        }
-      }
-      fieldSchema.enum = [fieldSchema.const]
-      delete fieldSchema.const
-    }
-  }
-}
-
-module.exports = JoiJsonDraftSchemaParser
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json')
+
+class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
+  constructor(opts = {}) {
+    super(_.merge({
+      $schema: 'http://json-schema.org/draft-04/schema#',
+      logicalOpParser: {
+        xor: null,
+        with: function (schema, dependency) {
+          schema.dependencies = schema.dependencies || {}
+          schema.dependencies[dependency.key] = dependency.peers
+        },
+        without: null
+      }
+    }, opts))
+  }
+
+  _isIfThenElseSupported() {
+    return false
+  }
+
+  _setNumberFieldProperties(fieldSchema, fieldDefn) {
+    super._setNumberFieldProperties(fieldSchema, fieldDefn)
+
+    if (typeof fieldSchema.exclusiveMinimum !== 'undefined') {
+      fieldSchema.minimum = fieldSchema.exclusiveMinimum
+      fieldSchema.exclusiveMinimum = true
+    }
+    if (typeof fieldSchema.exclusiveMaximum !== 'undefined') {
+      fieldSchema.maximum = fieldSchema.exclusiveMaximum
+      fieldSchema.exclusiveMaximum = true
+    }
+
+    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'
+  }
+
+  _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
+        if (fieldSchema.type === 'number' && Number.isInteger(fieldSchema.const)) {
+          fieldSchema.type = 'integer'
+        }
+      }
+      fieldSchema.enum = [fieldSchema.const]
+      delete fieldSchema.const
+    }
+  }
+}
+
+module.exports = JoiJsonDraftSchemaParser

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

@@ -1,16 +1,16 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json')
-
-class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
-  constructor(opts = {}) {
-    super(_.merge({
-      $schema: 'https://json-schema.org/draft/2019-09/schema'
-    }, opts))
-  }
-
-  _isKnownMetaKey(key) {
-    return key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
-  }
-}
-
-module.exports = JoiJsonDraftSchemaParser
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json')
+
+class JoiJsonDraftSchemaParser extends JoiJsonSchemaParser {
+  constructor(opts = {}) {
+    super(_.merge({
+      $schema: 'https://json-schema.org/draft/2019-09/schema'
+    }, opts))
+  }
+
+  _isKnownMetaKey(key) {
+    return key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
+  }
+}
+
+module.exports = JoiJsonDraftSchemaParser

package/lib/parsers/json.js

@@ -285,7 +285,6 @@ class JoiJsonSchemaParser {
     this._setIfNotEmpty(fieldSchema, 'enum', this._getEnum(fieldDefn))
     if (fieldDefn.invalid && fieldDefn.invalid.length > 0) {
       fieldSchema.not = {
-        type: fieldSchema.type,
         enum: fieldDefn.invalid
       }
     }
@@ -602,7 +601,7 @@ class JoiJsonSchemaParser {
 
     let ifThenStyle = this._isIfThenElseSupported()
     const styleSetting = _.remove(joiSpec.metas, (meta) => {
-      return typeof meta['if-style'] !== undefined
+      return typeof meta['if-style'] !== 'undefined'
     })
 
     if (ifThenStyle && styleSetting.length > 0 && styleSetting[0]['if-style'] === false) {

package/lib/parsers/open-api-3.1.js

@@ -1,31 +1,31 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json-draft-2019-09')
-
-class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
-  constructor(opts = {}) {
-    super(opts)
-
-    this.$schema = undefined
-  }
-
-  parse(joiSpec, definitions = {}, level = 0) {
-    const schema = super.parse(joiSpec, definitions, level)
-
-    if (level === 0 && !_.isEmpty(definitions)) {
-      schema.schemas = definitions
-    }
-    delete schema.components
-
-    return schema
-  }
-
-  _getLocalSchemaBasePath() {
-    return '#/components/schemas'
-  }
-
-  _isKnownMetaKey(key) {
-    return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
-  }
-}
-
-module.exports = JoiOpenApiSchemaParser
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json-draft-2019-09')
+
+class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
+  constructor(opts = {}) {
+    super(opts)
+
+    this.$schema = undefined
+  }
+
+  parse(joiSpec, definitions = {}, level = 0) {
+    const schema = super.parse(joiSpec, definitions, level)
+
+    if (level === 0 && !_.isEmpty(definitions)) {
+      schema.schemas = definitions
+    }
+    delete schema.components
+
+    return schema
+  }
+
+  _getLocalSchemaBasePath() {
+    return '#/components/schemas'
+  }
+
+  _isKnownMetaKey(key) {
+    return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
+  }
+}
+
+module.exports = JoiOpenApiSchemaParser

package/lib/parsers/open-api.js

@@ -1,134 +1,134 @@
-const _ = require('lodash')
-const JoiJsonSchemaParser = require('./json-draft-04')
-
-class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
-  constructor(opts = {}) {
-    super(_.merge({
-      logicalOpParser: {
-        xor: null,
-        with: null,
-        without: null
-      }
-    }, opts))
-
-    this.$schema = undefined
-  }
-
-  parse(joiSpec, definitions = {}, level = 0) {
-    const fullSchema = super.parse(joiSpec, definitions, level)
-    const schema = _.pickBy(fullSchema, (value, key) => isKnownKey(key))
-
-    if (level === 0 && !_.isEmpty(definitions)) {
-      schema.schemas = definitions
-    }
-
-    if (fullSchema.const) {
-      schema.enum = [fullSchema.const]
-    }
-
-    return schema
-  }
-
-  _isIfThenElseSupported() {
-    return false
-  }
-
-  _getLocalSchemaBasePath() {
-    return '#/components/schemas'
-  }
-
-  _setBasicProperties(fieldSchema, fieldDefn) {
-    super._setBasicProperties(fieldSchema, fieldDefn)
-
-    if (!_.isEmpty(fieldSchema.examples)) {
-      fieldSchema.example = fieldSchema.examples[0]
-    }
-  }
-
-  _addNullTypeIfNullable(fieldSchema, fieldDefn) {
-    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
-    }
-  }
-
-  _isKnownMetaKey(key) {
-    return isKnownMetaKey(key)
-  }
-}
-
-function isKnownMetaKey(key) {
-  return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
-}
-
-function isKnownKey(key) {
-  const knownKeys = new Set([
-    '$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'
-  ])
-  return knownKeys.has(key) || isKnownMetaKey(key)
-}
-
+const _ = require('lodash')
+const JoiJsonSchemaParser = require('./json-draft-04')
+
+class JoiOpenApiSchemaParser extends JoiJsonSchemaParser {
+  constructor(opts = {}) {
+    super(_.merge({
+      logicalOpParser: {
+        xor: null,
+        with: null,
+        without: null
+      }
+    }, opts))
+
+    this.$schema = undefined
+  }
+
+  parse(joiSpec, definitions = {}, level = 0) {
+    const fullSchema = super.parse(joiSpec, definitions, level)
+    const schema = _.pickBy(fullSchema, (value, key) => isKnownKey(key))
+
+    if (level === 0 && !_.isEmpty(definitions)) {
+      schema.schemas = definitions
+    }
+
+    if (fullSchema.const) {
+      schema.enum = [fullSchema.const]
+    }
+
+    return schema
+  }
+
+  _isIfThenElseSupported() {
+    return false
+  }
+
+  _getLocalSchemaBasePath() {
+    return '#/components/schemas'
+  }
+
+  _setBasicProperties(fieldSchema, fieldDefn) {
+    super._setBasicProperties(fieldSchema, fieldDefn)
+
+    if (!_.isEmpty(fieldSchema.examples)) {
+      fieldSchema.example = fieldSchema.examples[0]
+    }
+  }
+
+  _addNullTypeIfNullable(fieldSchema, fieldDefn) {
+    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
+    }
+  }
+
+  _isKnownMetaKey(key) {
+    return isKnownMetaKey(key)
+  }
+}
+
+function isKnownMetaKey(key) {
+  return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly'
+}
+
+function isKnownKey(key) {
+  const knownKeys = new Set([
+    '$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'
+  ])
+  return knownKeys.has(key) || isKnownMetaKey(key)
+}
+
 module.exports = JoiOpenApiSchemaParser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joi-to-json",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "joi to JSON / OpenAPI Schema Converter",
   "main": "index.js",
   "repository": {