@ditojs/server 1.7.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "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,10 +21,10 @@
     "node >= 16"
   ],
   "dependencies": {
-    "@ditojs/admin": "^1.7.0",
-    "@ditojs/build": "^1.7.0",
-    "@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",
@@ -79,5 +79,5 @@
     "knex": "^2.0.0",
     "objection": "^3.0.1"
   },
-  "gitHead": "20bdea5596f70da591987707df7aa5336ecb6aa3"
+  "gitHead": "bb2c9e85083eabc51d1f4b1fd0bffd6b306b0e47"
 }

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/models/Model.js

@@ -360,7 +360,10 @@ 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)

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/properties.js

@@ -1,19 +1,14 @@
 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)) {
     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()`:
+    // to JSON schema's `required` array through `convertProperties()`:
     const { required, ...rest } = schema
     schema = rest
     if (isString(type)) {
@@ -24,7 +19,7 @@ export function convertSchema(schema, options = {}) {
         if (jsonType === 'object') {
           let setAdditionalProperties = false
           if (schema.properties) {
-            const { properties, required } = expandProperties(
+            const { properties, required } = convertProperties(
               schema.properties,
               options
             )
@@ -35,7 +30,8 @@ export function convertSchema(schema, options = {}) {
             setAdditionalProperties = true
           }
           if (schema.patternProperties) {
-            const { properties } = expandProperties(
+            // TODO: Don't we need to handle required here too?
+            const { properties } = convertProperties(
               schema.patternProperties,
               options
             )
@@ -87,13 +83,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) {
@@ -119,11 +108,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,52 +120,6 @@ 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

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,89 +71,35 @@ describe('convertSchema()', () => {
 
   it(`expands 'text' typess to 'string' JSON schema typess`, () => {
     expect(convertSchema({
-      myText: {
-        type: 'text'
-      }
-    })).toEqual({
       type: 'object',
       properties: {
         myText: {
-          type: 'string'
-        }
-      },
-      additionalProperties: false
-    })
-  })
-
-  it('expands strings property short-hands to property schemas', () => {
-    expect(convertSchema({
-      myNumber: 'number'
-    })).toEqual({
-      type: 'object',
-      properties: {
-        myNumber: {
-          type: 'number'
+          type: 'text'
         }
-      },
-      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: []
+        myText: {
+          type: 'string'
         }
       },
       additionalProperties: false
     })
   })
 
-  it('expands nested array property and object short-hands', () => {
+  it('adds `required` arrays and formats for required properties', () => {
     expect(convertSchema({
-      myArray: [{
-        myNumber: 'number'
-      }]
-    })).toEqual({
       type: 'object',
       properties: {
-        myArray: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              myNumber: {
-                type: 'number'
-              }
-            },
-            additionalProperties: false
-          },
-          default: []
+        myString: {
+          type: 'string',
+          required: true
+        },
+        myNumber: {
+          type: 'number',
+          required: true
         }
-      },
-      additionalProperties: false
-    })
-  })
-
-  it('adds `required` arrays and formats for required properties', () => {
-    expect(convertSchema({
-      myString: {
-        type: 'string',
-        required: true
-      },
-      myNumber: {
-        type: 'number',
-        required: true
       }
     })).toEqual({
       type: 'object',
@@ -168,9 +120,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 +142,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 +165,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 +198,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 +228,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 +262,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 +281,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 +303,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 +324,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 +347,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 +369,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 +389,131 @@ 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('convert 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('support `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'
-          }
-        },
-        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'
-          },
-          prop2: {
-            type: 'number',
-            format: 'required'
+        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']
-  })
-})
-
-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'
-      },
-      default: []
-    })
-  })
-
-  it('expands objects property short-hands to object property schemas', () => {
-    expect(expandSchemaShorthand({
-      myNumber: {
-        type: 'number'
+        }
       }
     })).toEqual({
       type: 'object',
       properties: {
-        myNumber: {
-          type: 'number'
+        myObject: {
+          type: 'object',
+          format: 'required',
+          properties: {
+            prop1: {
+              format: 'required',
+              type: 'string'
+            },
+            prop2: {
+              format: 'required',
+              type: 'number'
+            }
+          },
+          additionalProperties: false,
+          required: ['prop1', 'prop2']
         }
-      }
+      },
+      additionalProperties: false,
+      required: ['myObject']
     })
   })
 })