@ditojs/server 1.8.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "1.8.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",
@@ -79,5 +79,5 @@
     "knex": "^2.0.0",
     "objection": "^3.0.1"
   },
-  "gitHead": "bb2c9e85083eabc51d1f4b1fd0bffd6b306b0e47"
+  "gitHead": "390e0a7e0782b3cb5cff5e5d0454a35c7a954df5"
 }

package/src/app/Validator.js

@@ -368,6 +368,7 @@ const validatorOptions = {
   $data: false,
   $comment: false,
   coerceTypes: false,
+  discriminator: true,
   multipleOfPrecision: false,
   ownProperties: true,
   removeAdditional: false,

package/src/schema/properties.js

@@ -5,51 +5,61 @@ export function convertSchema(schema, options = {}) {
     // Needed for allOf, anyOf, oneOf, not, items:
     schema = schema.map(entry => convertSchema(entry, options))
   } 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 `convertProperties()`:
-    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 } = convertProperties(
-              schema.properties,
-              options
-            )
-            schema.properties = properties
-            if (required.length > 0) {
-              schema.required = required
-            }
-            setAdditionalProperties = true
-          }
-          if (schema.patternProperties) {
-            // TODO: Don't we need to handle required here too?
-            const { properties } = convertProperties(
-              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.
@@ -57,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) {
@@ -82,19 +92,6 @@ export function convertSchema(schema, options = {}) {
           }
         }
       }
-    } else {
-      // 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
@@ -122,12 +119,13 @@ export function convertProperties(schemaProperties, options) {
 
 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

@@ -118,6 +118,25 @@ describe('convertSchema()', () => {
     })
   })
 
+  it('preserves JSON schema-style `required` arrays', () => {
+    expect(convertSchema({
+      type: 'object',
+      required: ['myString', 'myNumber'],
+      properties: {
+        myString: { type: 'string' },
+        myNumber: { type: 'number' }
+      }
+    })).toEqual({
+      type: 'object',
+      properties: {
+        myString: { type: 'string' },
+        myNumber: { type: 'number' }
+      },
+      additionalProperties: false,
+      required: ['myString', 'myNumber']
+    })
+  })
+
   it(`expands 'object' schemas with properties to JSON schemas allowing no additional properties`, () => {
     expect(convertSchema({
       type: 'object',
@@ -390,7 +409,7 @@ describe('convertSchema()', () => {
     })
   })
 
-  it('convert schemas within oneOf properties', () => {
+  it('converts schemas within oneOf properties', () => {
     expect(convertSchema({
       type: 'object',
       properties: {
@@ -473,7 +492,7 @@ describe('convertSchema()', () => {
     })
   })
 
-  it('support `required: true` on object', () => {
+  it('supports `required: true` on object', () => {
     expect(convertSchema({
       type: 'object',
       properties: {
@@ -516,4 +535,58 @@ describe('convertSchema()', () => {
       required: ['myObject']
     })
   })
+
+  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',
+      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']
+        }
+      ]
+    })
+  })
 })