@ditojs/server 1.6.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "1.6.0",
+  "version": "1.8.1",
   "type": "module",
   "description": "Dito.js Server – Dito.js is a declarative and modern web framework, based on Objection.js, Koa.js and Vue.js",
   "repository": "https://github.com/ditojs/dito/tree/master/packages/server",
@@ -21,16 +21,16 @@
     "node >= 16"
   ],
   "dependencies": {
-    "@ditojs/admin": "^1.6.0",
-    "@ditojs/build": "^1.5.5",
-    "@ditojs/router": "^1.6.0",
-    "@ditojs/utils": "^1.6.0",
+    "@ditojs/admin": "^1.8.0",
+    "@ditojs/build": "^1.8.0",
+    "@ditojs/router": "^1.8.0",
+    "@ditojs/utils": "^1.8.0",
     "@koa/cors": "^3.3.0",
     "@koa/multer": "^3.0.0",
     "@originjs/vite-plugin-commonjs": "^1.0.3",
     "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
-    "aws-sdk": "^2.1135.0",
+    "aws-sdk": "^2.1141.0",
     "axios": "^0.27.2",
     "bcryptjs": "^2.4.3",
     "bytes": "^3.1.2",
@@ -67,7 +67,7 @@
     "repl": "^0.1.3",
     "uuid": "^8.3.2",
     "vite": "^2.9.9",
-    "vite-plugin-vue2": "^2.0.0",
+    "vite-plugin-vue2": "^2.0.1",
     "vue": "^2.6.14",
     "vue-template-compiler": "^2.6.14"
   },
@@ -79,5 +79,5 @@
     "knex": "^2.0.0",
     "objection": "^3.0.1"
   },
-  "gitHead": "a442b0e47237fef8aeb65793fa3f5bc6621442ce"
+  "gitHead": "390e0a7e0782b3cb5cff5e5d0454a35c7a954df5"
 }

package/src/app/Application.js

@@ -454,9 +454,9 @@ export class Application extends Koa {
     } else if (parameters) {
       throw new Error(`Invalid parameters definition: ${parameters}`)
     }
-    // NOTE: If properties is null, schema and validate will become null too.
-    // NOTE: If it is not null, it will get expanded to an object schema.
-    const schema = convertSchema(properties, options)
+    const schema = properties
+      ? convertSchema({ type: 'object', properties }, options)
+      : null
     const validate = this.compileValidator(schema, {
       // For parameters, always coerce types, including arrays.
       coerceTypes: 'array',

package/src/app/Validator.js

@@ -1,5 +1,5 @@
 import objection from 'objection'
-import Ajv from 'ajv'
+import Ajv from 'ajv/dist/2020.js'
 import addFormats from 'ajv-formats'
 import { isArray, isObject, clone, isAsync, isPromise } from '@ditojs/utils'
 import { formatJson } from '../utils/index.js'
@@ -368,6 +368,7 @@ const validatorOptions = {
   $data: false,
   $comment: false,
   coerceTypes: false,
+  discriminator: true,
   multipleOfPrecision: false,
   ownProperties: true,
   removeAdditional: false,

package/src/models/Model.js

@@ -360,13 +360,15 @@ export class Model extends objection.Model {
 
   static get jsonSchema() {
     return this._getCached('jsonSchema', () => {
-      const schema = convertSchema(this.definition.properties)
+      const schema = convertSchema({
+        type: 'object',
+        properties: this.definition.properties
+      })
       addRelationSchemas(this, schema.properties)
       // Merge in root-level schema additions
       merge(schema, this.definition.schema)
       return {
         $id: this.name,
-        $schema: 'http://json-schema.org/draft-07/schema',
         ...schema
       }
     }, {})

package/src/models/definitions/properties.js

@@ -1,5 +1,4 @@
 import { mergeReversed } from '../../utils/index.js'
-import { expandSchemaShorthand } from '../../schema/index.js'
 
 export default function properties(values) {
   const properties = mergeReversed(values)
@@ -55,8 +54,7 @@ export default function properties(values) {
   // NOTE: Substitutions on all other levels happen in convertSchema()
   const ids = []
   const rest = []
-  for (let [name, property] of Object.entries(properties)) {
-    property = expandSchemaShorthand(property)
+  for (const [name, property] of Object.entries(properties)) {
     // Also sort properties by kind: primary id > foreign id > rest:
     const entry = [name, property]
     if (property.primary) {

package/src/schema/keywords/_range.js

@@ -2,11 +2,12 @@ export const range = {
   type: ['number', 'integer'],
   metaSchema: {
     type: 'array',
-    items: [
+    prefixItems: [
       { type: 'number' },
       { type: 'number' }
     ],
-    additionalItems: false
+    minItems: 2,
+    items: false
   },
   macro(config) {
     return {

package/src/schema/keywords/_validate.js

@@ -1,4 +1,4 @@
-import Ajv from 'ajv'
+import Ajv from 'ajv/dist/2020.js'
 import { isNumber, isArray } from '@ditojs/utils'
 
 export const validate = {

package/src/schema/properties.js

@@ -1,59 +1,65 @@
 import { isObject, isArray, isString } from '@ditojs/utils'
 
 export function convertSchema(schema, options = {}) {
-  if (isString(schema)) {
-    // TODO: Consider removing string short-hand
-    // Nested shorthand expansion
-    schema = { type: schema }
-  } else if (isArray(schema)) {
+  if (isArray(schema)) {
     // Needed for allOf, anyOf, oneOf, not, items:
     schema = schema.map(entry => convertSchema(entry, options))
-  }
-  if (isObject(schema)) {
+  } else if (isObject(schema)) {
+    // Create a shallow clone so we can modify and return:
+    schema = { ...schema }
     const { type } = schema
-    // Create a shallow clone so we can modify and return, excluding our
-    // `required` boolean which will get converted to a format further down, and
-    // to JSON schema's `required` array through `expandProperties()`:
-    const { required, ...rest } = schema
-    schema = rest
+    if (schema.required === true) {
+      // Our 'required' is not the same as JSON Schema's: Use the 'required'
+      // format instead that only validates if the required value is not empty,
+      // meaning neither nullish nor an empty string. The JSON schema `required`
+      // array is generated seperately below through `convertProperties()`.
+      delete schema.required
+      schema = addFormat(schema, 'required')
+    }
+
+    // Convert properties
+    let hasConvertedProperties = false
+    if (schema.properties) {
+      const { properties, required } = convertProperties(
+        schema.properties,
+        options
+      )
+      schema.properties = properties
+      if (required.length > 0) {
+        schema.required = required
+      }
+      hasConvertedProperties = true
+    }
+    if (schema.patternProperties) {
+      // TODO: Don't we need to handle required here too?
+      const { properties } = convertProperties(
+        schema.patternProperties,
+        options
+      )
+      schema.patternProperties = properties
+      hasConvertedProperties = true
+    }
+
+    // Convert array items
+    schema.prefixItems &&= convertSchema(schema.prefixItems, options)
+    schema.items &&= convertSchema(schema.items, options)
+
+    // Handle nested allOf, anyOf, oneOf, not fields
+    for (const key of ['allOf', 'anyOf', 'oneOf', 'not']) {
+      if (key in schema) {
+        schema[key] = convertSchema(schema[key], options)
+      }
+    }
+
     if (isString(type)) {
       // Convert schema property notation to JSON schema
       const jsonType = jsonTypes[type]
       if (jsonType) {
         schema.type = jsonType
-        if (jsonType === 'object') {
-          let setAdditionalProperties = false
-          if (schema.properties) {
-            const { properties, required } = expandProperties(
-              schema.properties,
-              options
-            )
-            schema.properties = properties
-            if (required.length > 0) {
-              schema.required = required
-            }
-            setAdditionalProperties = true
-          }
-          if (schema.patternProperties) {
-            const { properties } = expandProperties(
-              schema.patternProperties,
-              options
-            )
-            schema.patternProperties = properties
-            setAdditionalProperties = true
-          }
-          if (setAdditionalProperties) {
-            // Invert the logic of `additionalProperties` so that it needs to be
-            // explicitely set to `true`:
-            if (!('additionalProperties' in schema)) {
-              schema.additionalProperties = false
-            }
-          }
-        } else if (jsonType === 'array') {
-          const { items } = schema
-          if (items) {
-            schema.items = convertSchema(items, options)
-          }
+        if (hasConvertedProperties && !('additionalProperties' in schema)) {
+          // Invert the logic of `additionalProperties` so that it needs to be
+          // explicitely set to `true`:
+          schema.additionalProperties = false
         }
       } else if (['date', 'datetime', 'timestamp'].includes(type)) {
         // Date properties can be submitted both as a string or a Date object.
@@ -61,7 +67,7 @@ export function convertSchema(schema, options = {}) {
         // to handle both types correctly.
         schema.type = ['string', 'object']
         schema = addFormat(schema, 'date-time')
-      } else {
+      } else if (type !== 'null') {
         // A reference to another model as nested JSON data, use $ref or
         // instanceof instead of type, based on the passed option:
         if (options.useInstanceOf) {
@@ -86,26 +92,6 @@ export function convertSchema(schema, options = {}) {
           }
         }
       }
-    } else {
-      // This is a root properties schema or nested object without type that
-      // may need expanding.
-      const expanded = expandSchemaShorthand(schema)
-      schema = expanded !== schema
-        // Only call convertSchema() if it actually changed...
-        ? convertSchema(expanded, options)
-        : expanded
-      // Handle nested allOf, anyOf, oneOf, not properties
-      for (const key of ['allOf', 'anyOf', 'oneOf', 'not']) {
-        if (key in schema) {
-          schema[key] = convertSchema(schema[key], options)
-        }
-      }
-    }
-    if (required) {
-      // Our 'required' is not the same as JSON Schema's: Use the 'required'
-      // format instead that only validates if the required value is not
-      // empty, meaning neither nullish nor an empty string.
-      schema = addFormat(schema, 'required')
     }
     if (excludeDefaults[schema.default]) {
       delete schema.default
@@ -119,11 +105,10 @@ export function convertSchema(schema, options = {}) {
   return schema
 }
 
-export function expandProperties(schemaProperties, options) {
+export function convertProperties(schemaProperties, options) {
   const properties = {}
   const required = []
-  for (let [key, property] of Object.entries(schemaProperties)) {
-    property = expandSchemaShorthand(property)
+  for (const [key, property] of Object.entries(schemaProperties)) {
     properties[key] = convertSchema(property, options)
     if (property?.required) {
       required.push(key)
@@ -132,60 +117,15 @@ export function expandProperties(schemaProperties, options) {
   return { properties, required }
 }
 
-export function expandSchemaShorthand(schema) {
-  // TODO: Consider removing all short-hand schema expansion.
-  if (isString(schema)) {
-    schema = {
-      type: schema
-    }
-  } else if (isArray(schema)) {
-    schema = {
-      type: 'array',
-      items: schema.length > 1 ? schema : schema[0],
-      // The array short-forms sets an empty array as the default.
-      default: []
-    }
-  } else if (
-    // Expand objects to `type: 'object'`...
-    isObject(schema) &&
-    !(
-      // ...but only if they don't define any of these properties:
-      isString(schema.type) ||
-      isString(schema.$ref) ||
-      isArray(schema.allOf) ||
-      isArray(schema.anyOf) ||
-      isArray(schema.oneOf) ||
-      isObject(schema.not)
-    )
-  ) {
-    // Separate object short-hand into property definitions and other fields.
-    const properties = {}
-    const rest = {}
-    for (const [key, value] of Object.entries(schema)) {
-      // Property definitions are either objects or string / array short-hands:
-      if (isObject(value) || isString(value) || isArray(value)) {
-        properties[key] = value
-      } else {
-        rest[key] = value
-      }
-    }
-    schema = {
-      type: 'object',
-      properties,
-      ...rest
-    }
-  }
-  return schema
-}
-
 function addFormat(schema, newFormat) {
   // Support multiple `format` keywords through `allOf`:
-  let { allOf, format, ...rest } = schema
+  const { allOf, format, ...rest } = schema
   if (format || allOf) {
-    allOf ||= []
-    if (!allOf.find(({ format }) => format === newFormat)) {
-      allOf.push({ format }, { format: newFormat })
-      schema = { ...rest, allOf }
+    if (!allOf?.find(({ format }) => format === newFormat)) {
+      schema = {
+        ...rest,
+        allOf: [...(allOf ?? []), { format }, { format: newFormat }]
+      }
     }
   } else {
     schema.format = newFormat

package/src/schema/properties.test.js

@@ -1,4 +1,4 @@
-import { convertSchema, expandSchemaShorthand } from './properties.js'
+import { convertSchema } from './properties.js'
 
 describe('convertSchema()', () => {
   it('expands objects with properties to full JSON schemas', () => {
@@ -22,7 +22,10 @@ describe('convertSchema()', () => {
         type: 'array'
       }
     }
-    expect(convertSchema(properties)).toEqual({
+    expect(convertSchema({
+      type: 'object',
+      properties
+    })).toEqual({
       type: 'object',
       properties,
       additionalProperties: false
@@ -56,7 +59,10 @@ describe('convertSchema()', () => {
         default: null
       }
     }
-    expect(convertSchema(properties)).toEqual({
+    expect(convertSchema({
+      type: 'object',
+      properties
+    })).toEqual({
       type: 'object',
       properties,
       additionalProperties: false
@@ -65,8 +71,11 @@ describe('convertSchema()', () => {
 
   it(`expands 'text' typess to 'string' JSON schema typess`, () => {
     expect(convertSchema({
-      myText: {
-        type: 'text'
+      type: 'object',
+      properties: {
+        myText: {
+          type: 'text'
+        }
       }
     })).toEqual({
       type: 'object',
@@ -79,87 +88,49 @@ describe('convertSchema()', () => {
     })
   })
 
-  it('expands strings property short-hands to property schemas', () => {
+  it('adds `required` arrays and formats for required properties', () => {
     expect(convertSchema({
-      myNumber: 'number'
-    })).toEqual({
       type: 'object',
       properties: {
+        myString: {
+          type: 'string',
+          required: true
+        },
         myNumber: {
-          type: 'number'
+          type: 'number',
+          required: true
         }
-      },
-      additionalProperties: false
-    })
-  })
-
-  it('expands array property short-hands to array property schemas', () => {
-    expect(convertSchema({
-      myArray: [{
-        type: 'number'
-      }]
+      }
     })).toEqual({
       type: 'object',
       properties: {
-        myArray: {
-          type: 'array',
-          items: {
-            type: 'number'
-          },
-          default: []
+        myString: {
+          type: 'string',
+          format: 'required'
+        },
+        myNumber: {
+          type: 'number',
+          format: 'required'
         }
       },
-      additionalProperties: false
+      additionalProperties: false,
+      required: ['myString', 'myNumber']
     })
   })
 
-  it('expands nested array property and object short-hands', () => {
+  it('preserves JSON schema-style `required` arrays', () => {
     expect(convertSchema({
-      myArray: [{
-        myNumber: 'number'
-      }]
-    })).toEqual({
       type: 'object',
+      required: ['myString', 'myNumber'],
       properties: {
-        myArray: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              myNumber: {
-                type: 'number'
-              }
-            },
-            additionalProperties: false
-          },
-          default: []
-        }
-      },
-      additionalProperties: false
-    })
-  })
-
-  it('adds `required` arrays and formats for required properties', () => {
-    expect(convertSchema({
-      myString: {
-        type: 'string',
-        required: true
-      },
-      myNumber: {
-        type: 'number',
-        required: true
+        myString: { type: 'string' },
+        myNumber: { type: 'number' }
       }
     })).toEqual({
       type: 'object',
       properties: {
-        myString: {
-          type: 'string',
-          format: 'required'
-        },
-        myNumber: {
-          type: 'number',
-          format: 'required'
-        }
+        myString: { type: 'string' },
+        myNumber: { type: 'number' }
       },
       additionalProperties: false,
       required: ['myString', 'myNumber']
@@ -168,9 +139,12 @@ describe('convertSchema()', () => {
 
   it(`expands 'object' schemas with properties to JSON schemas allowing no additional properties`, () => {
     expect(convertSchema({
-      myText: {
-        type: 'object',
-        properties: {}
+      type: 'object',
+      properties: {
+        myText: {
+          type: 'object',
+          properties: {}
+        }
       }
     })).toEqual({
       type: 'object',
@@ -187,10 +161,13 @@ describe('convertSchema()', () => {
 
   it('preserves preexisting settings for no additional properties', () => {
     expect(convertSchema({
-      myText: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {}
+      type: 'object',
+      properties: {
+        myText: {
+          type: 'object',
+          additionalProperties: true,
+          properties: {}
+        }
       }
     })).toEqual({
       type: 'object',
@@ -207,12 +184,15 @@ describe('convertSchema()', () => {
 
   it('expands nested object schemas with required properties', () => {
     expect(convertSchema({
-      myText: {
-        type: 'object',
-        properties: {
-          myProperty: {
-            type: 'text',
-            required: true
+      type: 'object',
+      properties: {
+        myText: {
+          type: 'object',
+          properties: {
+            myProperty: {
+              type: 'text',
+              required: true
+            }
           }
         }
       }
@@ -237,11 +217,14 @@ describe('convertSchema()', () => {
 
   it(`expands 'object' schemas with patternProperties`, () => {
     expect(convertSchema({
-      myText: {
-        type: 'object',
-        patternProperties: {
-          '^.*$': {
-            type: 'text'
+      type: 'object',
+      properties: {
+        myText: {
+          type: 'object',
+          patternProperties: {
+            '^.*$': {
+              type: 'text'
+            }
           }
         }
       }
@@ -264,14 +247,17 @@ describe('convertSchema()', () => {
 
   it('expands datetime types to their JSON schema representation', () => {
     expect(convertSchema({
-      myDate: {
-        type: 'date'
-      },
-      myDateTime: {
-        type: 'datetime'
-      },
-      myTimeStamp: {
-        type: 'timestamp'
+      type: 'object',
+      properties: {
+        myDate: {
+          type: 'date'
+        },
+        myDateTime: {
+          type: 'datetime'
+        },
+        myTimeStamp: {
+          type: 'timestamp'
+        }
       }
     })).toEqual({
       type: 'object',
@@ -295,8 +281,11 @@ describe('convertSchema()', () => {
 
   it('expands unrecognized types to `$ref` references', () => {
     expect(convertSchema({
-      myModel: {
-        type: 'MyModel'
+      type: 'object',
+      properties: {
+        myModel: {
+          type: 'MyModel'
+        }
       }
     })).toEqual({
       type: 'object',
@@ -311,8 +300,11 @@ describe('convertSchema()', () => {
 
   it(`expands unrecognized types to \`instanceof\` keywords when the \`useInstanceOf\` option is provided`, () => {
     expect(convertSchema({
-      myModel: {
-        type: 'MyModel'
+      type: 'object',
+      properties: {
+        myModel: {
+          type: 'MyModel'
+        }
       }
     }, {
       useInstanceOf: true
@@ -330,9 +322,12 @@ describe('convertSchema()', () => {
 
   it('handles `nullable: true` correctly (now natively supported)', () => {
     expect(convertSchema({
-      myString: {
-        type: 'string',
-        nullable: true
+      type: 'object',
+      properties: {
+        myString: {
+          type: 'string',
+          nullable: true
+        }
       }
     })).toEqual({
       type: 'object',
@@ -348,9 +343,12 @@ describe('convertSchema()', () => {
 
   it(`handles \`nullable: true\` references correctly`, () => {
     expect(convertSchema({
-      myModel: {
-        type: 'MyModel',
-        nullable: true
+      type: 'object',
+      properties: {
+        myModel: {
+          type: 'MyModel',
+          nullable: true
+        }
       }
     })).toEqual({
       type: 'object',
@@ -368,9 +366,12 @@ describe('convertSchema()', () => {
 
   it(`handles \`nullable: true\` dates correctly (now natively supported)`, () => {
     expect(convertSchema({
-      myDate: {
-        type: 'date',
-        nullable: true
+      type: 'object',
+      properties: {
+        myDate: {
+          type: 'date',
+          nullable: true
+        }
       }
     })).toEqual({
       type: 'object',
@@ -387,10 +388,13 @@ describe('convertSchema()', () => {
 
   it(`handles \`nullable: true\` enums correctly`, () => {
     expect(convertSchema({
-      myEnum: {
-        type: 'string',
-        enum: ['one', 'two', 'three'],
-        nullable: true
+      type: 'object',
+      properties: {
+        myEnum: {
+          type: 'string',
+          enum: ['one', 'two', 'three'],
+          nullable: true
+        }
       }
     })).toEqual({
       type: 'object',
@@ -404,195 +408,185 @@ describe('convertSchema()', () => {
       additionalProperties: false
     })
   })
-})
 
-it('convert schemas within oneOf properties', () => {
-  expect(convertSchema({
-    myList: {
-      type: 'array',
-      items: {
-        oneOf: [
-          {
-            prop1: {
-              type: 'string',
-              required: true
-            },
-            prop2: {
-              type: 'number',
-              required: true
-            }
-          },
-          {
-            type: 'object',
-            properties: {
-              prop3: {
-                type: 'string',
-                required: true
+  it('converts schemas within oneOf properties', () => {
+    expect(convertSchema({
+      type: 'object',
+      properties: {
+        myList: {
+          type: 'array',
+          items: {
+            oneOf: [
+              {
+                type: 'object',
+                properties: {
+                  prop1: {
+                    type: 'string',
+                    required: true
+                  },
+                  prop2: {
+                    type: 'number',
+                    required: true
+                  }
+                }
               },
-              prop4: {
-                type: 'number',
-                required: true
+              {
+                type: 'object',
+                properties: {
+                  prop3: {
+                    type: 'string',
+                    required: true
+                  },
+                  prop4: {
+                    type: 'number',
+                    required: true
+                  }
+                }
               }
-            }
+            ]
           }
-        ]
+        }
       }
-    }
-  })).toEqual({
-    type: 'object',
-    properties: {
-      myList: {
-        type: 'array',
-        items: {
-          oneOf: [
-            {
-              type: 'object',
-              properties: {
-                prop1: {
-                  type: 'string',
-                  format: 'required'
+    })).toEqual({
+      type: 'object',
+      properties: {
+        myList: {
+          type: 'array',
+          items: {
+            oneOf: [
+              {
+                type: 'object',
+                properties: {
+                  prop1: {
+                    type: 'string',
+                    format: 'required'
+                  },
+                  prop2: {
+                    type: 'number',
+                    format: 'required'
+                  }
                 },
-                prop2: {
-                  type: 'number',
-                  format: 'required'
-                }
+                required: ['prop1', 'prop2'],
+                additionalProperties: false
               },
-              required: ['prop1', 'prop2'],
-              additionalProperties: false
-            },
-            {
-              type: 'object',
-              properties: {
-                prop3: {
-                  type: 'string',
-                  format: 'required'
+              {
+                type: 'object',
+                properties: {
+                  prop3: {
+                    type: 'string',
+                    format: 'required'
+                  },
+                  prop4: {
+                    type: 'number',
+                    format: 'required'
+                  }
                 },
-                prop4: {
-                  type: 'number',
-                  format: 'required'
-                }
-              },
-              required: ['prop3', 'prop4'],
-              additionalProperties: false
-            }
-          ]
+                required: ['prop3', 'prop4'],
+                additionalProperties: false
+              }
+            ]
+          }
         }
-      }
-    },
-    additionalProperties: false
+      },
+      additionalProperties: false
+    })
   })
-})
 
-it('support `required: true` on object', () => {
-  expect(convertSchema({
-    myObject: {
+  it('supports `required: true` on object', () => {
+    expect(convertSchema({
       type: 'object',
-      required: true,
       properties: {
-        prop1: {
-          type: 'string',
-          required: true
-        },
-        prop2: {
-          type: 'number',
-          required: true
-        }
-      }
-    }
-  })).toEqual({
-    type: 'object',
-    properties: {
-      myObject: {
-        type: 'object',
-        format: 'required',
-        properties: {
-          prop1: {
-            format: 'required',
-            type: 'string'
-          },
-          prop2: {
-            format: 'required',
-            type: 'number'
+        myObject: {
+          type: 'object',
+          required: true,
+          properties: {
+            prop1: {
+              type: 'string',
+              required: true
+            },
+            prop2: {
+              type: 'number',
+              required: true
+            }
           }
-        },
-        additionalProperties: false,
-        required: ['prop1', 'prop2']
-      }
-    },
-    additionalProperties: false,
-    required: ['myObject']
-  })
-})
-
-it('support `required` on object short-hand', () => {
-  expect(convertSchema({
-    myObject: {
-      required: true,
-      prop1: {
-        type: 'string',
-        required: true
-      },
-      prop2: {
-        type: 'number',
-        required: true
+        }
       }
-    }
-  })).toEqual({
-    type: 'object',
-    properties: {
-      myObject: {
-        type: 'object',
-        format: 'required',
-        properties: {
-          prop1: {
-            type: 'string',
-            format: 'required'
+    })).toEqual({
+      type: 'object',
+      properties: {
+        myObject: {
+          type: 'object',
+          format: 'required',
+          properties: {
+            prop1: {
+              format: 'required',
+              type: 'string'
+            },
+            prop2: {
+              format: 'required',
+              type: 'number'
+            }
           },
-          prop2: {
-            type: 'number',
-            format: 'required'
-          }
-        },
-        additionalProperties: false,
-        required: ['prop1', 'prop2']
-      }
-    },
-    additionalProperties: false,
-    required: ['myObject']
-  })
-})
-
-describe('expandSchemaShorthand()', () => {
-  it('expands strings to schemas', () => {
-    expect(expandSchemaShorthand('number')).toEqual({
-      type: 'number'
-    })
-  })
-
-  it('expands array property short-hands to array property schemas', () => {
-    expect(expandSchemaShorthand([{
-      type: 'number'
-    }])).toEqual({
-      type: 'array',
-      items: {
-        type: 'number'
+          additionalProperties: false,
+          required: ['prop1', 'prop2']
+        }
       },
-      default: []
+      additionalProperties: false,
+      required: ['myObject']
     })
   })
 
-  it('expands objects property short-hands to object property schemas', () => {
-    expect(expandSchemaShorthand({
-      myNumber: {
-        type: 'number'
-      }
+  it('processes discriminator schemas correctly', () => {
+    expect(convertSchema({
+      type: 'object',
+      discriminator: { propertyName: 'foo' },
+      required: ['foo'],
+      oneOf: [
+        {
+          properties: {
+            foo: { const: 'x' },
+            a: {
+              type: 'string',
+              required: true
+            }
+          }
+        },
+        {
+          properties: {
+            foo: { enum: ['y', 'z'] },
+            b: {
+              type: 'string',
+              required: true
+            }
+          }
+        }
+      ]
     })).toEqual({
       type: 'object',
-      properties: {
-        myNumber: {
-          type: 'number'
+      discriminator: { propertyName: 'foo' },
+      required: ['foo'],
+      oneOf: [
+        {
+          properties: {
+            foo: { const: 'x' },
+            a: {
+              type: 'string',
+              format: 'required'
+            }
+          },
+          required: ['a']
+        },
+        {
+          properties: {
+            foo: { enum: ['y', 'z'] },
+            b: {
+              type: 'string',
+              format: 'required'
+            }
+          },
+          required: ['b']
         }
-      }
+      ]
     })
   })
 })