@ditojs/server 2.52.0 → 2.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "2.52.0",
+  "version": "2.53.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",
@@ -26,12 +26,12 @@
     "node >= 18"
   ],
   "dependencies": {
-    "@ditojs/admin": "^2.52.0",
-    "@ditojs/build": "^2.52.0",
-    "@ditojs/router": "^2.52.0",
-    "@ditojs/utils": "^2.52.0",
+    "@ditojs/admin": "^2.53.0",
+    "@ditojs/build": "^2.53.0",
+    "@ditojs/router": "^2.53.0",
+    "@ditojs/utils": "^2.53.0",
     "@koa/cors": "^5.0.0",
-    "@koa/multer": "^3.1.0",
+    "@koa/multer": "^4.0.0",
     "@originjs/vite-plugin-commonjs": "^1.0.3",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
@@ -39,14 +39,14 @@
     "bytes": "^3.1.2",
     "data-uri-to-buffer": "^6.0.2",
     "eventemitter2": "^6.4.9",
-    "file-type": "^20.5.0",
+    "file-type": "^21.0.0",
     "helmet": "^8.1.0",
     "koa": "^3.0.0",
     "koa-bodyparser": "^4.4.1",
     "koa-compose": "^4.1.0",
     "koa-compress": "^5.1.1",
     "koa-conditional-get": "^3.0.0",
-    "koa-etag": "^4.0.0",
+    "koa-etag": "^5.0.0",
     "koa-helmet": "^8.0.1",
     "koa-mount": "^4.2.0",
     "koa-passport": "^6.0.0",
@@ -55,7 +55,7 @@
     "koa-static": "^5.0.0",
     "leather": "^3.0.3",
     "mime-types": "^3.0.1",
-    "multer": "^1.4.5-lts.2",
+    "multer": "^2.0.1",
     "multer-s3": "https://github.com/ditojs/multer-s3#dito",
     "nanoid": "^5.1.5",
     "parse-duration": "^2.1.4",
@@ -63,7 +63,7 @@
     "passthrough-counter": "^1.0.0",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.2",
-    "pino": "^9.6.0",
+    "pino": "^9.7.0",
     "pino-pretty": "^13.0.0",
     "pluralize": "^8.0.0",
     "repl": "^0.1.3",
@@ -77,18 +77,18 @@
     "objection": "^3.0.1"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "^3.701.0",
-    "@aws-sdk/lib-storage": "^3.701.0",
+    "@aws-sdk/client-s3": "^3.832.0",
+    "@aws-sdk/lib-storage": "^3.832.0",
     "@types/koa-bodyparser": "^4.3.12",
     "@types/koa-compress": "^4.0.6",
     "@types/koa-response-time": "^2.1.5",
     "@types/koa-session": "^6.4.5",
     "@types/koa-static": "^4.0.4",
     "@types/koa__cors": "^5.0.0",
-    "@types/node": "^22.15.18",
+    "@types/node": "^24.0.3",
     "knex": "^3.1.0",
     "objection": "^3.1.5",
     "typescript": "^5.8.3"
   },
-  "gitHead": "dbfde6b475d824a88fbbbc1e007fd264e80d46fb"
+  "gitHead": "7f36fa29f11708527b85e37233b83ecf6bf40497"
 }

package/src/models/Model.js

@@ -390,21 +390,13 @@ export class Model extends objection.Model {
     return this._getCached(
       'jsonSchema',
       () => {
-        const definitions = {}
-        const schema = convertSchema(
-          {
-            type: 'object',
-            properties: this.definition.properties
-          },
-          { definitions }
-        )
+        const schema = convertSchema({
+          type: 'object',
+          properties: this.definition.properties
+        })
         addRelationSchemas(this, schema.properties)
         // Merge in root-level schema additions
         assignDeeply(schema, this.definition.schema)
-        // Merge in definitions
-        if (Object.keys(definitions).length > 0) {
-          schema.definitions = definitions
-        }
         return {
           $id: this.name,
           ...schema

package/src/schema/schema.js

@@ -1,17 +1,42 @@
 import { isObject, isArray, isString, equals } from '@ditojs/utils'
 
-export function convertSchema(schema, options = {}) {
+const schemaCaches = {}
+
+function getSchemaCache(options) {
+  const key = Object.entries(options || {})
+    .toSorted()
+    .map(([key, value]) => `${key}:${value}`)
+    .join(',') || 'default'
+  return (schemaCaches[key] ||= new WeakMap())
+}
+
+export function convertSchema(schema, options = {}, rootDefinitions = null) {
+  const original = schema
+
+  const schemaCache = getSchemaCache(options)
+  if (schemaCache.has(original)) {
+    const { schema, definitions } = schemaCache.get(original)
+    mergeDefinitions(rootDefinitions, definitions)
+    return schema
+  }
+
+  let definitions = null
   if (isArray(schema)) {
     // Needed for allOf, anyOf, oneOf, not, items, see below:
-    schema = schema.map(entry => convertSchema(entry, options))
+    schema = schema.map(entry => convertSchema(entry, options, rootDefinitions))
   } else if (isObject(schema)) {
+    const isRoot = rootDefinitions === null
+    rootDefinitions ??= {}
+
     // Create a shallow clone so we can modify and return:
     // Also collect and propagate the definitions up to the root schema through
     // `options.definitions`, as passed from `Model static get jsonSchema()`:
-    const { definitions, ...rest } = schema
-    mergeDefinitions(options.definitions, definitions, options)
+    const { definitions: defs, ...rest } = schema
+    definitions = defs
     schema = rest
     const { $ref, type } = schema
+    const jsonType = jsonTypes[type]
+
     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,
@@ -21,37 +46,22 @@ export function convertSchema(schema, options = {}) {
       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)
+    schema.prefixItems &&= convertSchema(
+      schema.prefixItems,
+      options,
+      rootDefinitions
+    )
+    schema.items &&= convertSchema(
+      schema.items,
+      options,
+      rootDefinitions
+    )
 
     // Handle nested allOf, anyOf, oneOf & co. fields
     for (const key of ['allOf', 'anyOf', 'oneOf', 'not', '$extend']) {
       if (key in schema) {
-        schema[key] = convertSchema(schema[key], options)
+        schema[key] = convertSchema(schema[key], options, rootDefinitions)
       }
     }
 
@@ -62,18 +72,8 @@ export function convertSchema(schema, options = {}) {
         ? `#/definitions/${$ref}`
         : $ref
     } else if (isString(type)) {
-      // Convert schema property notation to JSON schema
-      const jsonType = jsonTypes[type]
       if (jsonType) {
         schema.type = jsonType
-        if (
-          (hasConvertedProperties || schema.discriminator) &&
-          !('unevaluatedProperties' in schema)
-        ) {
-          // Invert the logic of `unevaluatedProperties` so that it needs to be
-          // explicitly set to `true`:
-          schema.unevaluatedProperties = false
-        }
       } else if (['date', 'datetime', 'timestamp'].includes(type)) {
         // Date properties can be submitted both as a string or a Date object.
         // Provide validation through date-time format, which in Ajv appears
@@ -114,44 +114,108 @@ export function convertSchema(schema, options = {}) {
     if (schema.nullable && schema.enum && !schema.enum.includes(null)) {
       schema.enum.push(null)
     }
+
+    // Only convert properties after the schema is remembered, to avoid endless
+    // recursion in circular schema definitions.
+    let hasConvertedProperties = false
+    if (schema.properties) {
+      const { properties, required } = convertProperties(
+        schema.properties,
+        options,
+        rootDefinitions
+      )
+      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,
+        rootDefinitions
+      )
+      schema.patternProperties = properties
+      hasConvertedProperties = true
+    }
+    if (
+      jsonType &&
+      (hasConvertedProperties || schema.discriminator) &&
+      !('unevaluatedProperties' in schema)
+    ) {
+      // Invert the logic of `unevaluatedProperties` so that it needs to be
+      // explicitly set to `true`:
+      schema.unevaluatedProperties = false
+    }
+
+    if (isRoot && hasDefinitions(rootDefinitions)) {
+      schema.definitions = rootDefinitions
+    }
+  }
+
+  const entry = { schema, definitions: null }
+  schemaCache.set(original, entry)
+
+  // To prevent circular references, we need to convert the definitions
+  // after the schema entry is cached.
+  if (definitions) {
+    definitions = convertDefinitions(definitions, options)
+    mergeDefinitions(rootDefinitions, definitions)
+    entry.definitions = definitions
   }
+
   return schema
 }
 
-function convertProperties(schemaProperties, options) {
+function convertProperties(schemaProperties, options, definitions = {}) {
   const properties = {}
   const required = []
   for (const [key, property] of Object.entries(schemaProperties)) {
-    properties[key] = convertSchema(property, options)
+    properties[key] = convertSchema(property, options, definitions)
     if (property?.required) {
       required.push(key)
     }
   }
-  return { properties, required }
+  return { properties, required, definitions }
+}
+
+function hasDefinitions(definitions) {
+  return definitions && Object.keys(definitions).length > 0
+}
+
+function convertDefinitions(definitions, options) {
+  const converted = {}
+  for (const [key, schema] of Object.entries(definitions)) {
+    if (!key.startsWith('#')) {
+      throw new Error(
+        `Invalid definition '${
+          key
+        }', the name of nested Dito.js definitions must start with '#': ${
+          JSON.stringify(schema)
+        }`
+      )
+    }
+    converted[key] = convertSchema(schema, options, converted)
+  }
+  return hasDefinitions(converted) ? converted : null
 }
 
-function mergeDefinitions(definitions, defs, options) {
+function mergeDefinitions(definitions, defs) {
   if (definitions && defs) {
     for (const [key, def] of Object.entries(defs)) {
-      if (!key.startsWith('#')) {
-        throw new Error(
-          `Invalid definition '${
-            key
-          }', the name of nested Dito.js definitions must start with '#': ${
-            JSON.stringify(def)
-          }`
-        )
-      }
       const definition = definitions[key]
-      const converted = convertSchema(def, options)
-      if (definition && !equals(definition, converted)) {
+      if (definition && !equals(definition, def)) {
         throw new Error(
           `Duplicate nested definition for '${key}' with different schema: ${
-            JSON.stringify(def)
+            JSON.stringify(def, null, 2)
+          }, ${
+            JSON.stringify(definition, null, 2)
           }`
         )
       }
-      definitions[key] = converted
+      definitions[key] = def
     }
   }
 }

package/src/schema/schema.test.js

@@ -633,7 +633,6 @@ describe('convertSchema()', () => {
   })
 
   it('supports nested Dito.js definitions', () => {
-    const definitions = {}
     expect(
       convertSchema(
         {
@@ -653,8 +652,18 @@ describe('convertSchema()', () => {
                 '#type2': {
                   type: 'object',
                   properties: {
-                    prop3: {
+                    prop4: {
                       type: 'string'
+                    },
+
+                    prop5: {
+                      $ref: '#type3'
+                    }
+                  },
+
+                  definitions: {
+                    '#type3': {
+                      type: 'boolean'
                     }
                   }
                 }
@@ -667,8 +676,7 @@ describe('convertSchema()', () => {
               type: 'integer'
             }
           }
-        },
-        { definitions }
+        }
       )
     ).toEqual({
       type: 'object',
@@ -686,19 +694,25 @@ describe('convertSchema()', () => {
             }
           }
         }
-      }
-    })
-    expect(definitions).toEqual({
-      '#type1': {
-        type: 'integer'
       },
-      '#type2': {
-        type: 'object',
-        unevaluatedProperties: false,
-        properties: {
-          prop3: {
-            type: 'string'
+      definitions: {
+        '#type1': {
+          type: 'integer'
+        },
+        '#type2': {
+          type: 'object',
+          unevaluatedProperties: false,
+          properties: {
+            prop4: {
+              type: 'string'
+            },
+            prop5: {
+              $ref: '#/definitions/#type3'
+            }
           }
+        },
+        '#type3': {
+          type: 'boolean'
         }
       }
     })