@ditojs/server 1.8.0 → 1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "1.8.0",
+  "version": "1.9.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,24 +21,24 @@
     "node >= 16"
   ],
   "dependencies": {
-    "@ditojs/admin": "^1.8.0",
+    "@ditojs/admin": "^1.9.1",
     "@ditojs/build": "^1.8.0",
-    "@ditojs/router": "^1.8.0",
-    "@ditojs/utils": "^1.8.0",
+    "@ditojs/router": "^1.9.0",
+    "@ditojs/utils": "^1.9.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.1141.0",
+    "aws-sdk": "^2.1180.0",
     "axios": "^0.27.2",
     "bcryptjs": "^2.4.3",
     "bytes": "^3.1.2",
     "data-uri-to-buffer": "^4.0.0",
-    "eventemitter2": "^6.4.5",
-    "file-type": "^17.1.1",
+    "eventemitter2": "^6.4.6",
+    "file-type": "^17.1.3",
     "fs-extra": "^10.1.0",
-    "image-size": "^1.0.1",
+    "image-size": "^1.0.2",
     "is-svg": "^4.3.2",
     "koa": "^2.13.4",
     "koa-bodyparser": "^4.3.0",
@@ -53,31 +53,31 @@
     "koa-session": "^6.2.0",
     "koa-static": "^5.0.0",
     "mime-types": "^2.1.35",
-    "multer": "^1.4.4",
+    "multer": "^1.4.5-lts.1",
     "multer-s3": "^2.10.0",
-    "nanoid": "^3.3.4",
+    "nanoid": "^4.0.0",
     "parse-duration": "^1.0.2",
     "passport-local": "^1.0.0",
     "passthrough-counter": "^1.0.0",
     "picocolors": "^1.0.0",
     "picomatch": "^2.3.1",
-    "pino": "^7.11.0",
-    "pino-pretty": "^7.6.1",
+    "pino": "^8.3.0",
+    "pino-pretty": "^8.1.0",
     "pluralize": "^8.0.0",
     "repl": "^0.1.3",
     "uuid": "^8.3.2",
-    "vite": "^2.9.9",
-    "vite-plugin-vue2": "^2.0.1",
-    "vue": "^2.6.14",
-    "vue-template-compiler": "^2.6.14"
+    "vite": "^3.0.2",
+    "vite-plugin-vue2": "^2.0.2",
+    "vue": "^2.7.8",
+    "vue-template-compiler": "^2.7.8"
   },
   "peerDependencies": {
     "knex": "^1.0.5",
     "objection": "^3.0.1"
   },
   "devDependencies": {
-    "knex": "^2.0.0",
+    "knex": "^2.2.0",
     "objection": "^3.0.1"
   },
-  "gitHead": "bb2c9e85083eabc51d1f4b1fd0bffd6b306b0e47"
+  "gitHead": "36ad7c74fedaf7ea7c94eb5bb7ecb4b2dca3a0ba"
 }

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/controllers/AdminController.js

@@ -15,7 +15,7 @@ import { merge } from '@ditojs/utils'
 import { Controller } from './Controller.js'
 import { handleConnectMiddleware } from '../middleware/index.js'
 import { ControllerError } from '../errors/index.js'
-import { formatJson, deprecate } from '../utils/index.js'
+import { formatJson, getRandomFreePort, deprecate } from '../utils/index.js'
 
 export class AdminController extends Controller {
   // @override
@@ -130,7 +130,12 @@ export class AdminController extends Controller {
     const server = await createServer({
       ...config,
       server: {
-        middlewareMode: 'html',
+        middlewareMode: true,
+        hmr: {
+          // Use a random free port instead of vite's default 24678, since we
+          // may be running multiple servers in parallel (e.g. e2e and dev).
+          port: await getRandomFreePort()
+        },
         watch: {
           // Watch the @ditojs packages while in dev mode, although they are
           // inside the node_modules folder.

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']
+        }
+      ]
+    })
+  })
 })

package/src/utils/index.js

@@ -4,5 +4,6 @@ export * from './emitter.js'
 export * from './function.js'
 export * from './handler.js'
 export * from './json.js'
+export * from './net.js'
 export * from './object.js'
 export * from './scope.js'

package/src/utils/net.js

@@ -0,0 +1,17 @@
+import net from 'net'
+
+export async function getRandomFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer()
+    srv.listen(0, () => {
+      const port = srv.address().port
+      srv.close(err => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(port)
+        }
+      })
+    })
+  })
+}