@ditojs/server 2.96.0 → 2.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "2.96.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.96.0",
-    "@ditojs/build": "^2.96.0",
-    "@ditojs/router": "^2.96.0",
-    "@ditojs/utils": "^2.96.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": "689f4d061088500884114c5ced79d68209717bc5"
+  "gitHead": "70d0c1d3aa16844959e3c06d71d8253f21abad3f"
 }

package/src/app/Application.js

@@ -924,7 +924,7 @@ export class Application extends Koa {
     changedFiles,
     transaction = null
   ) {
-    let importedFiles = []
+    let importedFiles
     const AssetModel = this.getModel('Asset')
     if (AssetModel) {
       importedFiles = await this.addForeignAssets(

package/src/models/Model.js

@@ -12,6 +12,7 @@ import {
   parseDataPath,
   normalizeDataPath,
   getValueAtDataPath,
+  getEntriesAtDataPath,
   setValueAtDataPath,
   mapConcurrently,
   assignDeeply,
@@ -481,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
   }
 
@@ -1018,14 +1038,20 @@ export class Model extends objection.Model {
     const { assets } = this.definition
     if (assets) {
       for (const dataPath in assets) {
-        const data = getValueAtDataPath(json, dataPath, noop)
-        if (!data) continue
         const storage = this.app.getStorage(assets[dataPath].storage)
-        setValueAtDataPath(
-          json,
-          dataPath,
-          mapAssetFiles(data, storage, callback)
-        )
+        // Wildcard data paths (e.g. `**.file`) expand to multiple concrete
+        // paths; iterate them so each match is written back to its own
+        // location instead of the flattened wildcard result.
+        const entries = getEntriesAtDataPath(json, dataPath, noop)
+        for (const [path, data] of Object.entries(entries)) {
+          if (data) {
+            setValueAtDataPath(
+              json,
+              path,
+              mapAssetFiles(data, storage, callback)
+            )
+          }
+        }
       }
     }
   }

package/src/models/Model.test.js

@@ -0,0 +1,180 @@
+import { Model } from './Model.js'
+
+function makeFakeModel(assets) {
+  const storage = {
+    signAssetFile(file) {
+      file.signature = `sig-of-${file.key}`
+    }
+  }
+  return {
+    app: {
+      getStorage(name) {
+        return name === 'test' ? storage : null
+      }
+    },
+    definition: { assets }
+  }
+}
+
+function signCallback(file, storage) {
+  const signed = { ...file }
+  storage.signAssetFile(signed)
+  return signed
+}
+
+describe('Model._mapAssetFiles: asset signing across data paths', () => {
+  it('writes the signature back to a literal data path', () => {
+    const model = makeFakeModel({ 'image.file': { storage: 'test' } })
+    const json = { image: { file: { key: 'foo.png' } } }
+    Model._mapAssetFiles.call(model, json, signCallback)
+    expect(json.image.file.signature).toBe('sig-of-foo.png')
+  })
+
+  it('writes the signature back to every match of a deep wildcard', () => {
+    const model = makeFakeModel({ '**.file': { storage: 'test' } })
+    const json = {
+      content: {
+        file: { key: 'a.png' },
+        sections: [
+          { file: { key: 'b.png' } },
+          { file: { key: 'c.png' } }
+        ]
+      }
+    }
+    Model._mapAssetFiles.call(model, json, signCallback)
+    expect(json.content.file.signature).toBe('sig-of-a.png')
+    expect(json.content.sections[0].file.signature).toBe('sig-of-b.png')
+    expect(json.content.sections[1].file.signature).toBe('sig-of-c.png')
+  })
+
+  it('writes the signature back into wildcard array values', () => {
+    const model = makeFakeModel({ '**.files': { storage: 'test' } })
+    const json = {
+      content: {
+        files: [{ key: 'x.png' }, { key: 'y.png' }]
+      }
+    }
+    Model._mapAssetFiles.call(model, json, signCallback)
+    expect(json.content.files[0].signature).toBe('sig-of-x.png')
+    expect(json.content.files[1].signature).toBe('sig-of-y.png')
+  })
+
+  it('is a no-op when the wildcard matches nothing', () => {
+    const model = makeFakeModel({ '**.file': { storage: 'test' } })
+    const json = { name: 'no-files-here' }
+    Model._mapAssetFiles.call(model, json, signCallback)
+    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('')
+  })
+})