@ditojs/server 2.97.0 → 2.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "2.97.0",
+  "version": "2.98.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/main/packages/server",
@@ -25,10 +25,10 @@
     "node >= 18"
   ],
   "dependencies": {
-    "@ditojs/admin": "^2.97.0",
-    "@ditojs/build": "^2.97.0",
-    "@ditojs/router": "^2.97.0",
-    "@ditojs/utils": "^2.97.0",
+    "@ditojs/admin": "^2.98.0",
+    "@ditojs/build": "^2.98.0",
+    "@ditojs/router": "^2.98.0",
+    "@ditojs/utils": "^2.98.0",
     "@koa/cors": "^5.0.0",
     "@koa/etag": "^5.0.2",
     "@koa/multer": "^4.0.0",
@@ -90,5 +90,5 @@
     "objection": "^3.1.5",
     "typescript": "^6.0.3"
   },
-  "gitHead": "a15b3aa1474b88b4dbefd114491605b5715a6526"
+  "gitHead": "70d0c1d3aa16844959e3c06d71d8253f21abad3f"
 }

package/src/models/Model.js

@@ -482,6 +482,25 @@ export class Model extends objection.Model {
         }
       }
     }
+    // `discriminator`/`oneOf`/`anyOf`/`allOf` schemas don't always carry an
+    // explicit top-level `type`, so callers checking `property.type` (e.g.
+    // `loadDataPath()`, which gates traversal of nested data paths on the
+    // root being object/array) reject them. Fill in the type when it can be
+    // inferred unambiguously: a `discriminator` implies an object, and a
+    // homogeneous `oneOf`/`anyOf`/`allOf` adopts its branches' shared type.
+    if (property && !property.type) {
+      if (property.discriminator) {
+        property = { ...property, type: 'object' }
+      } else {
+        const branches = property.oneOf || property.anyOf || property.allOf
+        const types = new Set(
+          branches?.map(branch => branch?.type).filter(Boolean)
+        )
+        if (types.size === 1) {
+          property = { ...property, type: [...types][0] }
+        }
+      }
+    }
     return property ?? null
   }
 

package/src/models/Model.test.js

@@ -66,3 +66,115 @@ describe('Model._mapAssetFiles: asset signing across data paths', () => {
     expect(json).toEqual({ name: 'no-files-here' })
   })
 })
+
+describe('Model.getProperty: type inference for $ref/discriminator schemas', () => {
+  function getProperty({ name, properties, definitions = {} }) {
+    return Model.getProperty.call(
+      { definition: { properties }, jsonSchema: { definitions } },
+      name
+    )
+  }
+
+  it('returns the property unchanged when it has an explicit type', () => {
+    expect(
+      getProperty({
+        name: 'name',
+        properties: { name: { type: 'string' } }
+      })
+    ).toEqual({ type: 'string' })
+  })
+
+  it('infers type: object from a discriminator on a $ref schema', () => {
+    const property = getProperty({
+      name: 'content',
+      properties: { content: { $ref: '#StoryContent' } },
+      definitions: {
+        '#StoryContent': {
+          discriminator: { propertyName: 'type' },
+          oneOf: [
+            { type: 'object', properties: { type: { const: 'a' } } },
+            { type: 'object', properties: { type: { const: 'b' } } }
+          ]
+        }
+      }
+    })
+    expect(property.type).toBe('object')
+    expect(property.discriminator).toEqual({ propertyName: 'type' })
+  })
+
+  it('infers a shared type from a homogeneous oneOf', () => {
+    const property = getProperty({
+      name: 'content',
+      properties: {
+        content: { oneOf: [{ type: 'object' }, { type: 'object' }] }
+      }
+    })
+    expect(property.type).toBe('object')
+  })
+
+  it('infers a shared type from a homogeneous anyOf', () => {
+    const property = getProperty({
+      name: 'content',
+      properties: {
+        content: { anyOf: [{ type: 'array' }, { type: 'array' }] }
+      }
+    })
+    expect(property.type).toBe('array')
+  })
+
+  it('leaves type undefined when oneOf branches disagree', () => {
+    const property = getProperty({
+      name: 'content',
+      properties: {
+        content: { oneOf: [{ type: 'object' }, { type: 'string' }] }
+      }
+    })
+    expect(property.type).toBeUndefined()
+  })
+
+  it('returns null for an unknown property', () => {
+    expect(getProperty({ name: 'missing', properties: {} })).toBeNull()
+  })
+})
+
+describe('Model.getPropertyOrRelationAtDataPath: traversal through inferred types', () => {
+  function lookup({ dataPath, properties, definitions = {} }) {
+    const host = {
+      definition: { properties },
+      jsonSchema: { definitions },
+      getRelations: () => ({}),
+      getProperty(name) {
+        return Model.getProperty.call(this, name)
+      }
+    }
+    return Model.getPropertyOrRelationAtDataPath.call(host, dataPath)
+  }
+
+  it('exposes object type for a discriminator-rooted nested wildcard path', () => {
+    // Reproduces the original loadDataPath() crash on
+    // `content.article.items[**].file`: before the fix, `content` had
+    // no resolved `type`, so loadDataPath rejected the nested path.
+    const result = lookup({
+      dataPath: 'content.article.items[**].file',
+      properties: { content: { $ref: '#StoryContent' } },
+      definitions: {
+        '#StoryContent': {
+          discriminator: { propertyName: 'type' },
+          oneOf: [{ type: 'object' }]
+        }
+      }
+    })
+    expect(result.property.type).toBe('object')
+    expect(result.nestedDataPath).toBe('article/items/**/file')
+    expect(result.dataPath).toBe('content')
+  })
+
+  it('returns no nestedDataPath for a leaf property lookup', () => {
+    const result = lookup({
+      dataPath: 'name',
+      properties: { name: { type: 'string' } }
+    })
+    expect(result.property).toEqual({ type: 'string' })
+    expect(result.nestedDataPath).toBe('')
+  })
+})