@ditojs/server 3.0.0 → 3.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "3.0.0",
+  "version": "3.1.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/main/packages/server",
@@ -10,7 +10,9 @@
   "types": "./types/index.d.ts",
   "files": [
     "src/",
-    "types/"
+    "types/",
+    "!src/**/*.test.js",
+    "!src/**/__snapshots__/"
   ],
   "bin": {
     "dito": "./src/cli/index.js"
@@ -22,10 +24,10 @@
     "node >= 18"
   ],
   "dependencies": {
-    "@ditojs/admin": "^3.0.0",
-    "@ditojs/build": "^3.0.0",
-    "@ditojs/router": "^3.0.0",
-    "@ditojs/utils": "^3.0.0",
+    "@ditojs/admin": "^3.1.1",
+    "@ditojs/build": "^3.1.1",
+    "@ditojs/router": "^3.1.1",
+    "@ditojs/utils": "^3.1.1",
     "@koa/cors": "^5.0.0",
     "@koa/etag": "^5.0.2",
     "@koa/multer": "^4.0.0",
@@ -87,5 +89,5 @@
     "objection": "^3.1.5",
     "typescript": "^6.0.3"
   },
-  "gitHead": "399f683a6ca227a03cfc0978fee9055383e6b3d8"
+  "gitHead": "acce85bb38d817aab18f9d5d03b3aa9dff00c3f9"
 }

package/src/models/Model.test.js

@@ -1,180 +0,0 @@
-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('')
-  })
-})

package/src/schema/relations.test.js

@@ -1,177 +0,0 @@
-import {
-  BelongsToOneRelation,
-  HasOneRelation,
-  HasOneThroughRelation,
-  HasManyRelation,
-  ManyToManyRelation
-} from 'objection'
-import { Model } from '../models/index.js'
-import {
-  getRelationClass,
-  convertRelation,
-  addRelationSchemas
-} from './relations.js'
-
-describe('getRelationClass()', () => {
-  it('returns the corresponding relation classes', () => {
-    expect(getRelationClass('belongs-to')).toBe(BelongsToOneRelation)
-    expect(getRelationClass('has-one')).toBe(HasOneRelation)
-    expect(getRelationClass('has-one-through')).toBe(HasOneThroughRelation)
-    expect(getRelationClass('has-many')).toBe(HasManyRelation)
-    expect(getRelationClass('many-to-many')).toBe(ManyToManyRelation)
-
-    expect(getRelationClass('belongsTo')).toBe(BelongsToOneRelation)
-    expect(getRelationClass('hasOne')).toBe(HasOneRelation)
-    expect(getRelationClass('hasOneThrough')).toBe(HasOneThroughRelation)
-    expect(getRelationClass('hasMany')).toBe(HasManyRelation)
-    expect(getRelationClass('manyToMany')).toBe(ManyToManyRelation)
-
-    expect(getRelationClass('BelongsToOneRelation')).toBe(BelongsToOneRelation)
-    expect(getRelationClass('HasOneRelation')).toBe(HasOneRelation)
-    expect(getRelationClass('HasOneThroughRelation'))
-      .toBe(HasOneThroughRelation)
-    expect(getRelationClass('HasManyRelation')).toBe(HasManyRelation)
-    expect(getRelationClass('ManyToManyRelation')).toBe(ManyToManyRelation)
-  })
-})
-
-describe('convertRelation()', () => {
-  class ModelOne extends Model {}
-  class ModelTwo extends Model {}
-
-  const models = { ModelOne, ModelTwo }
-
-  it('converts a belongs-to relation to Objection.js format', () => {
-    expect(
-      convertRelation(
-        {
-          relation: 'belongs-to',
-          from: 'ModelOne.modelTwoId',
-          to: 'ModelTwo.id',
-          modify: 'myScope'
-        },
-        models
-      )
-    ).toEqual({
-      relation: BelongsToOneRelation,
-      modelClass: ModelTwo,
-      join: {
-        from: 'ModelOne.modelTwoId',
-        to: 'ModelTwo.id'
-      },
-      modify: 'myScope'
-    })
-  })
-
-  it('converts a many-to-many relation to Objection.js format', () => {
-    expect(
-      convertRelation(
-        {
-          relation: 'many-to-many',
-          from: 'ModelOne.id',
-          to: 'ModelTwo.id',
-          inverse: false
-        },
-        models
-      )
-    ).toEqual({
-      relation: ManyToManyRelation,
-      modelClass: ModelTwo,
-      join: {
-        from: 'ModelOne.id',
-        through: {
-          from: 'ModelOneModelTwo.modelOneId',
-          to: 'ModelOneModelTwo.modelTwoId'
-        },
-        to: 'ModelTwo.id'
-      }
-    })
-  })
-
-  it('converts an inverse many-to-many relation to Objection.js format', () => {
-    expect(
-      convertRelation(
-        {
-          relation: 'many-to-many',
-          from: 'ModelTwo.id',
-          to: 'ModelOne.id',
-          inverse: true
-        },
-        models
-      )
-    ).toEqual({
-      relation: ManyToManyRelation,
-      modelClass: ModelOne,
-      join: {
-        from: 'ModelTwo.id',
-        through: {
-          from: 'ModelOneModelTwo.modelTwoId',
-          to: 'ModelOneModelTwo.modelOneId'
-        },
-        to: 'ModelOne.id'
-      }
-    })
-  })
-
-  it('preserves Objection.js relation format', () => {
-    const relation = {
-      relation: BelongsToOneRelation,
-      modelClass: ModelTwo,
-      join: {
-        from: 'ModelOne.modelTwoId',
-        to: 'ModelTwo.id'
-      },
-      modify: 'myScope'
-    }
-    expect(convertRelation(relation, models)).toEqual(relation)
-  })
-})
-
-describe('addRelationSchemas()', () => {
-  class ModelOne extends Model {
-    static relations = {
-      modelTwo: {
-        relation: 'belongs-to',
-        from: 'ModelOne.modelTwoId',
-        to: 'ModelTwo.id'
-      }
-    }
-  }
-
-  class ModelTwo extends Model {
-    static relations = {
-      modelOnes: {
-        relation: 'has-many',
-        from: 'ModelTwo.id',
-        to: 'ModelOne.modelTwoId',
-        owner: true
-      }
-    }
-  }
-
-  // Add a mock app to both, to expose models:
-  ModelOne.app = ModelTwo.app = {
-    models: { ModelOne, ModelTwo }
-  }
-
-  it('adds correct property schema for a belongs-to relation', () => {
-    expect(addRelationSchemas(ModelOne, {})).toEqual({
-      modelTwo: {
-        anyOf: [
-          { type: 'null' },
-          { relate: 'ModelTwo' },
-          { $ref: 'ModelTwo' }
-        ]
-      }
-    })
-  })
-
-  it('adds correct property schema for a has-many owner relation', () => {
-    expect(addRelationSchemas(ModelTwo, {})).toEqual({
-      modelOnes: {
-        type: 'array',
-        items: { $ref: 'ModelOne' }
-      }
-    })
-  })
-})

package/src/schema/schema.test.js

@@ -1,720 +0,0 @@
-import { convertSchema } from './schema.js'
-
-describe('convertSchema()', () => {
-  it('expands objects with properties to full JSON schemas', () => {
-    const properties = {
-      myString: {
-        type: 'string'
-      },
-      myNumber: {
-        type: 'number'
-      },
-      myInteger: {
-        type: 'integer'
-      },
-      myBoolean: {
-        type: 'boolean'
-      },
-      myObject: {
-        type: 'object'
-      },
-      myArray: {
-        type: 'array'
-      }
-    }
-    expect(
-      convertSchema({
-        type: 'object',
-        properties
-      })
-    ).toEqual({
-      type: 'object',
-      properties,
-      unevaluatedProperties: false
-    })
-  })
-
-  it('supports falsy default values', () => {
-    const properties = {
-      myString: {
-        type: 'string',
-        default: ''
-      },
-      myNumber: {
-        type: 'number',
-        default: 0
-      },
-      myInteger: {
-        type: 'integer',
-        default: 0
-      },
-      myBoolean: {
-        type: 'boolean',
-        default: false
-      },
-      myObject: {
-        type: 'object',
-        default: null
-      },
-      myArray: {
-        type: 'array',
-        default: null
-      }
-    }
-    expect(
-      convertSchema({
-        type: 'object',
-        properties
-      })
-    ).toEqual({
-      type: 'object',
-      properties,
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`expands 'text' types to 'string' JSON schema types`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myText: {
-            type: 'text'
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myText: {
-          type: 'string'
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('adds `required` arrays and formats for required properties', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myString: {
-            type: 'string',
-            required: true
-          },
-          myNumber: {
-            type: 'number',
-            required: true
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myString: {
-          type: 'string',
-          format: 'required'
-        },
-        myNumber: {
-          type: 'number',
-          format: 'required'
-        }
-      },
-      unevaluatedProperties: false,
-      required: ['myString', 'myNumber']
-    })
-  })
-
-  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' }
-      },
-      unevaluatedProperties: false,
-      required: ['myString', 'myNumber']
-    })
-  })
-
-  it(`expands 'object' schemas with properties to JSON schemas allowing no unevaluated properties`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myText: {
-            type: 'object',
-            properties: {}
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myText: {
-          type: 'object',
-          unevaluatedProperties: false,
-          properties: {}
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('preserves pre-existing settings for no unevaluated properties', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myText: {
-            type: 'object',
-            unevaluatedProperties: true,
-            properties: {}
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myText: {
-          type: 'object',
-          unevaluatedProperties: true,
-          properties: {}
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('expands nested object schemas with required properties', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myText: {
-            type: 'object',
-            properties: {
-              myProperty: {
-                type: 'text',
-                required: true
-              }
-            }
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myText: {
-          type: 'object',
-          properties: {
-            myProperty: {
-              type: 'string',
-              format: 'required'
-            }
-          },
-          unevaluatedProperties: false,
-          required: ['myProperty']
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`expands 'object' schemas with patternProperties`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myText: {
-            type: 'object',
-            patternProperties: {
-              '^.*$': {
-                type: 'text'
-              }
-            }
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myText: {
-          type: 'object',
-          patternProperties: {
-            '^.*$': {
-              type: 'string'
-            }
-          },
-          unevaluatedProperties: false
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('expands datetime types to their JSON schema representation', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myDate: {
-            type: 'date'
-          },
-          myDateTime: {
-            type: 'datetime'
-          },
-          myTimeStamp: {
-            type: 'timestamp'
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myDate: {
-          type: ['string', 'object'],
-          format: 'date-time'
-        },
-        myDateTime: {
-          type: ['string', 'object'],
-          format: 'date-time'
-        },
-        myTimeStamp: {
-          type: ['string', 'object'],
-          format: 'date-time'
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('expands unrecognized types to `$ref` references', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myModel: {
-            type: 'MyModel'
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myModel: {
-          $ref: 'MyModel'
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`expands unrecognized types to \`instanceof\` keywords when the \`useInstanceOf\` option is provided`, () => {
-    expect(
-      convertSchema(
-        {
-          type: 'object',
-          properties: {
-            myModel: {
-              type: 'MyModel'
-            }
-          }
-        },
-        {
-          useInstanceOf: true
-        }
-      )
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myModel: {
-          type: 'object',
-          instanceof: 'MyModel'
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('handles `nullable: true` correctly (now natively supported)', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myString: {
-            type: 'string',
-            nullable: true
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myString: {
-          type: 'string',
-          nullable: true
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`handles \`nullable: true\` references correctly`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myModel: {
-            type: 'MyModel',
-            nullable: true
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myModel: {
-          oneOf: [
-            { type: 'null' },
-            { $ref: 'MyModel' }
-          ]
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`handles \`nullable: true\` dates correctly (now natively supported)`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myDate: {
-            type: 'date',
-            nullable: true
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myDate: {
-          type: ['string', 'object'],
-          format: 'date-time',
-          nullable: true
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it(`handles \`nullable: true\` enums correctly`, () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myEnum: {
-            type: 'string',
-            enum: ['one', 'two', 'three'],
-            nullable: true
-          }
-        }
-      })
-    ).toEqual({
-      type: 'object',
-      properties: {
-        myEnum: {
-          type: 'string',
-          enum: ['one', 'two', 'three', null],
-          nullable: true
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('converts 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
-                    }
-                  }
-                },
-                {
-                  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'
-                  },
-                  prop2: {
-                    type: 'number',
-                    format: 'required'
-                  }
-                },
-                required: ['prop1', 'prop2'],
-                unevaluatedProperties: false
-              },
-              {
-                type: 'object',
-                properties: {
-                  prop3: {
-                    type: 'string',
-                    format: 'required'
-                  },
-                  prop4: {
-                    type: 'number',
-                    format: 'required'
-                  }
-                },
-                required: ['prop3', 'prop4'],
-                unevaluatedProperties: false
-              }
-            ]
-          }
-        }
-      },
-      unevaluatedProperties: false
-    })
-  })
-
-  it('supports `required: true` on object', () => {
-    expect(
-      convertSchema({
-        type: 'object',
-        properties: {
-          myObject: {
-            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'
-            }
-          },
-          unevaluatedProperties: false,
-          required: ['prop1', 'prop2']
-        }
-      },
-      unevaluatedProperties: false,
-      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' },
-      unevaluatedProperties: false,
-      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']
-        }
-      ]
-    })
-  })
-
-  it('supports nested Dito.js definitions', () => {
-    expect(
-      convertSchema(
-        {
-          type: 'object',
-          properties: {
-            prop1: {
-              $ref: '#type1'
-            },
-            prop2: {
-              type: 'object',
-              properties: {
-                prop3: {
-                  $ref: '#type2'
-                }
-              },
-              definitions: {
-                '#type2': {
-                  type: 'object',
-                  properties: {
-                    prop4: {
-                      type: 'string'
-                    },
-
-                    prop5: {
-                      $ref: '#type3'
-                    }
-                  },
-
-                  definitions: {
-                    '#type3': {
-                      type: 'boolean'
-                    }
-                  }
-                }
-              }
-            }
-          },
-
-          definitions: {
-            '#type1': {
-              type: 'integer'
-            }
-          }
-        }
-      )
-    ).toEqual({
-      type: 'object',
-      unevaluatedProperties: false,
-      properties: {
-        prop1: {
-          $ref: '#/definitions/#type1'
-        },
-        prop2: {
-          type: 'object',
-          unevaluatedProperties: false,
-          properties: {
-            prop3: {
-              $ref: '#/definitions/#type2'
-            }
-          }
-        }
-      },
-      definitions: {
-        '#type1': {
-          type: 'integer'
-        },
-        '#type2': {
-          type: 'object',
-          unevaluatedProperties: false,
-          properties: {
-            prop4: {
-              type: 'string'
-            },
-            prop5: {
-              $ref: '#/definitions/#type3'
-            }
-          }
-        },
-        '#type3': {
-          type: 'boolean'
-        }
-      }
-    })
-  })
-})

package/src/storage/Storage.test.js

@@ -1,58 +0,0 @@
-import { Storage } from './Storage.js'
-
-function createStorage(keys = ['test-secret']) {
-  const app = { keys }
-  return new Storage(app, { name: 'test' })
-}
-
-function simulateUpload(storage, key, originalname) {
-  return storage.convertStorageFile({
-    key,
-    originalname,
-    mimetype: 'image/png',
-    size: 2048
-  })
-}
-
-describe('Storage: asset key signature verification', () => {
-  it('preserves the key through a full upload-then-save cycle', () => {
-    const storage = createStorage()
-    const uploaded = simulateUpload(storage, 'real-key.png', 'photo.png')
-    const fromClient = { ...uploaded }
-    storage.convertAssetFile(fromClient, { trusted: false })
-    expect(fromClient.key).toBe('real-key.png')
-  })
-
-  it('throws when a forged key is submitted', () => {
-    const storage = createStorage()
-    const file = { key: 'victim-key.png', name: 'photo.png' }
-    expect(() => {
-      storage.convertAssetFile(file, { trusted: false })
-    }).toThrow('Invalid asset signature')
-  })
-
-  it('throws when a valid signature is paired with a swapped key', () => {
-    const storage = createStorage()
-    const uploaded = simulateUpload(storage, 'legit.png', 'legit.png')
-    const forged = { ...uploaded, key: 'victim-file.png' }
-    expect(() => {
-      storage.convertAssetFile(forged, { trusted: false })
-    }).toThrow('Invalid asset signature')
-  })
-
-  it('does not throw when addFile() converts a server-created file', async () => {
-    const storage = createStorage()
-    const file = { key: 'imported.png', name: 'import.png' }
-    const data = Buffer.from('fake-image-data')
-    await storage.addFile(file, data)
-    expect(file.key).toBe('imported.png')
-  })
-
-  it('strips signature after conversion', () => {
-    const storage = createStorage()
-    const uploaded = simulateUpload(storage, 'upload.png', 'photo.png')
-    const fromClient = { ...uploaded }
-    storage.convertAssetFile(fromClient, { trusted: false })
-    expect('signature' in fromClient).toBe(false)
-  })
-})

package/src/utils/function.test.js

@@ -1,77 +0,0 @@
-import { describeFunction } from './function.js'
-
-describe('describeFunction()', () => {
-  it('describes normal functions', () => {
-    expect(
-      describeFunction(function (a, b, c) {
-        return a + b + c
-      })
-    )
-      .toBe('function (a, b, c) { ... }')
-  })
-
-  it('describes lambdas with one param and a body', () => {
-    expect(
-      describeFunction(a => {
-        return a
-      })
-    )
-      .toBe('a => { ... }')
-  })
-
-  it('describes lambdas with one param and no body', () => {
-    expect(describeFunction(a => a))
-      .toBe('a => ...')
-  })
-
-  it('describes lambdas with multiple params and a body', () => {
-    expect(
-      describeFunction((a, b, c) => {
-        return a + b + c
-      })
-    )
-      .toBe('(a, b, c) => { ... }')
-  })
-
-  it('describes lambdas with multiple params and no body', () => {
-    expect(describeFunction((a, b, c) => a + b + c))
-      .toBe('(a, b, c) => ...')
-  })
-
-  it('describes async functions', () => {
-    expect(
-      describeFunction(async function (a, b, c) {
-        return a + b + c
-      })
-    )
-      .toBe('async function (a, b, c) { ... }')
-  })
-
-  it('describes async lambdas with one param and a body', () => {
-    expect(
-      describeFunction(async a => {
-        return a
-      })
-    )
-      .toBe('async a => { ... }')
-  })
-
-  it('describes async lambdas with one param and no body', () => {
-    expect(describeFunction(async a => a))
-      .toBe('async a => ...')
-  })
-
-  it('describes async lambdas with multiple params and a body', () => {
-    expect(
-      describeFunction(async (a, b, c) => {
-        return a + b + c
-      })
-    )
-      .toBe('async (a, b, c) => { ... }')
-  })
-
-  it('describes async lambdas with multiple params and no body', () => {
-    expect(describeFunction(async (a, b, c) => a + b + c))
-      .toBe('async (a, b, c) => ...')
-  })
-})

package/src/utils/object.test.js

@@ -1,86 +0,0 @@
-import {
-  getAllKeys,
-  getOwnProperty,
-  createLookup,
-  mergeReversed,
-  mergeAsReversedArrays
-} from './object.js'
-
-const object = Object.create({ a: 1 })
-object.b = 2
-
-describe('getAllKeys()', () => {
-  it('returns all keys, not just own keys', () => {
-    expect(getAllKeys(object)).toEqual(['b', 'a'])
-  })
-})
-
-describe('getOwnProperty()', () => {
-  it('only returns own properties', () => {
-    expect(getOwnProperty(object, 'a')).toBeUndefined()
-    expect(getOwnProperty(object, 'b')).toBe(2)
-  })
-})
-
-describe('createLookup()', () => {
-  it('creates lookup objects out of arrays of strings', () => {
-    expect(createLookup(['a', 'b'])).toEqual({
-      a: true,
-      b: true
-    })
-  })
-})
-
-describe('mergeReversed()', () => {
-  it('merges property values in reversed order', () => {
-    expect(
-      mergeReversed([
-        {
-          a: 3
-        },
-        {
-          a: 2,
-          b: 2
-        },
-        {
-          a: 1,
-          b: 1,
-          c: 1
-        }
-      ])
-    ).toEqual({
-      a: 3,
-      b: 2,
-      c: 1
-    })
-  })
-})
-
-describe('mergeAsReversedArrays()', () => {
-  it('merges property values into arrays', () => {
-    expect(
-      mergeAsReversedArrays([
-        {
-          a: 1,
-          b: 1,
-          c: 1
-        },
-        {
-          a: 2,
-          b: 2
-        },
-        {
-          a: 3
-        }
-      ])
-    ).toEqual({
-      a: [3, 2, 1],
-      b: [2, 1],
-      c: [1]
-    })
-  })
-})
-
-describe.skip('setupPropertyInheritance()', () => {
-  // TODO: Add unit tests for this!
-})