@ditojs/server 1.13.1 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/server",
-  "version": "1.13.1",
+  "version": "1.14.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",
@@ -25,15 +25,14 @@
     "node >= 18"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.200.0",
-    "@ditojs/admin": "^1.13.1",
-    "@ditojs/build": "^1.13.0",
-    "@ditojs/router": "^1.13.1",
-    "@ditojs/utils": "^1.13.1",
+    "@ditojs/admin": "^1.14.0",
+    "@ditojs/build": "^1.14.0",
+    "@ditojs/router": "^1.14.0",
+    "@ditojs/utils": "^1.14.0",
     "@koa/cors": "^4.0.0",
-    "@koa/multer": "^3.0.0",
+    "@koa/multer": "^3.0.2",
     "@originjs/vite-plugin-commonjs": "^1.0.3",
-    "ajv": "^8.11.0",
+    "ajv": "^8.11.2",
     "ajv-formats": "^2.1.1",
     "bcryptjs": "^2.4.3",
     "bytes": "^3.1.2",
@@ -69,17 +68,19 @@
     "pluralize": "^8.0.0",
     "repl": "^0.1.3",
     "uuid": "^9.0.0",
-    "vite": "^3.2.2",
+    "vite": "^3.2.4",
     "vite-plugin-vue2": "^2.0.2",
-    "vue": "^2.7.13",
-    "vue-template-compiler": "^2.7.13"
+    "vue": "^2.7.14",
+    "vue-template-compiler": "^2.7.14"
   },
   "peerDependencies": {
+    "@aws-sdk/client-s3": "^3.0.0",
     "knex": ">=2.0.5",
     "objection": "^3.0.1"
   },
   "devDependencies": {
-    "@types/koa-bodyparser": "^4.3.9",
+    "@aws-sdk/client-s3": "^3.200.0",
+    "@types/koa-bodyparser": "^4.3.10",
     "@types/koa-compress": "^4.0.3",
     "@types/koa-logger": "^3.1.2",
     "@types/koa-pino-logger": "^3.0.1",
@@ -90,9 +91,9 @@
     "@types/node": "^18.11.9",
     "knex": "^2.3.0",
     "objection": "^3.0.1",
-    "type-fest": "^3.1.0",
-    "typescript": "^4.8.4"
+    "type-fest": "^3.2.0",
+    "typescript": "^4.9.3"
   },
   "types": "types",
-  "gitHead": "0c6a508e04ca915691c1fb0f3706827c8ecfe0ab"
+  "gitHead": "ba197ae5254deb657b2c3b5dab7a851f488e022a"
 }

package/src/app/Application.js

@@ -19,6 +19,7 @@ import session from 'koa-session'
 import etag from 'koa-etag'
 import helmet from 'koa-helmet'
 import responseTime from 'koa-response-time'
+import { Model, knexSnakeCaseMappers, ref } from 'objection'
 import Router from '@ditojs/router'
 import {
   isArray, isObject, isString, asArray, isPlainObject, isModule,
@@ -31,7 +32,7 @@ import { Controller, AdminController } from '../controllers/index.js'
 import { Service } from '../services/index.js'
 import { Storage } from '../storage/index.js'
 import { convertSchema } from '../schema/index.js'
-import { formatJson } from '../utils/index.js'
+import { deprecate, formatJson } from '../utils/index.js'
 import {
   ResponseError,
   ValidationError,
@@ -47,12 +48,6 @@ import {
   handleUser,
   logRequests
 } from '../middleware/index.js'
-import {
-  Model,
-  BelongsToOneRelation,
-  knexSnakeCaseMappers,
-  ref
-} from 'objection'
 
 export class Application extends Koa {
   constructor({
@@ -61,12 +56,12 @@ export class Application extends Koa {
     router,
     events,
     middleware,
-    models,
     services,
+    models,
     controllers
   } = {}) {
     super()
-    this._setupEmitter(events)
+    this._configureEmitter(events)
     const {
       // Pluck keys out of `config.app` to keep them secret
       app: { keys, ...app } = {},
@@ -84,12 +79,13 @@ export class Application extends Koa {
     this.router = router || new Router()
     this.validator.app = this
     this.storages = Object.create(null)
-    this.models = Object.create(null)
     this.services = Object.create(null)
+    this.models = Object.create(null)
     this.controllers = Object.create(null)
     this.server = null
     this.isRunning = false
 
+    // TODO: Rename setup to configure?
     this.setupLogger()
     this.setupKnex()
     this.setupMiddleware(middleware)
@@ -97,17 +93,24 @@ export class Application extends Koa {
     if (config.storages) {
       this.addStorages(config.storages)
     }
-    if (models) {
-      this.addModels(models)
-    }
     if (services) {
       this.addServices(services)
     }
+    if (models) {
+      this.addModels(models)
+    }
     if (controllers) {
       this.addControllers(controllers)
     }
   }
 
+  async setup() {
+    await this.setupStorages()
+    await this.setupServices()
+    await this.setupModels()
+    await this.setupControllers()
+  }
+
   addRoute(
     method, path, transacted, middlewares, controller = null, action = null
   ) {
@@ -133,121 +136,56 @@ export class Application extends Koa {
     this.router[method](path, route)
   }
 
-  addModels(models) {
-    // First add all models then call initialize() for each in a second loop,
-    // since they may be referencing each other in relations.
-    for (const modelClass of Object.values(models)) {
-      this.addModel(modelClass)
-    }
-    // Now (re-)sort all models based on their relations.
-    this.models = this.sortModels(this.models)
-    // Filter through all sorted models, keeping only the newly added ones.
-    const sortedModels = Object.values(this.models).filter(
-      modelClass => models[modelClass.name] === modelClass
-    )
-    // Initialize the added models in correct sorted sequence, so that for every
-    // model, getRelatedRelations() returns the full list of relating relations.
-    for (const modelClass of sortedModels) {
-      if (models[modelClass.name] === modelClass) {
-        modelClass.setup(this.knex)
-        // Now that the modelClass is set up, call `initialize()`, which can be
-        // overridden by sub-classes,without having to call `super.initialize()`
-        modelClass.initialize()
-        this.validator.addSchema(modelClass.getJsonSchema())
+  getStorage(name) {
+    return this.storages[name] || null
+  }
+
+  addStorage(config, name) {
+    let storage = null
+    if (isPlainObject(config)) {
+      const storageClass = Storage.get(config.type)
+      if (!storageClass) {
+        throw new Error(`Unsupported storage: ${config}`)
       }
+      // eslint-disable-next-line new-cap
+      storage = new storageClass(this, config)
+    } else if (config instanceof Storage) {
+      storage = config
     }
-    const { log } = this.config
-    if (log.schema || log.relations) {
-      for (const modelClass of sortedModels) {
-        const shouldLog = option => (
-          option === true ||
-          asArray(option).includes(modelClass.name)
-        )
-        const data = {}
-        if (shouldLog(log.schema)) {
-          data.schema = modelClass.getJsonSchema()
-        }
-        if (shouldLog(log.relations)) {
-          data.relations = clone(modelClass.relationMappings, value =>
-            Model.isPrototypeOf(value) ? `[Model: ${value.name}]` : value
-          )
-        }
-        if (Object.keys(data).length > 0) {
-          console.info(
-            pico.yellow(pico.bold(`\n${modelClass.name}:\n`)),
-            util.inspect(data, {
-              colors: true,
-              depth: null,
-              maxArrayLength: null
-            })
-          )
-        }
+    if (storage) {
+      if (name) {
+        storage.name = name
       }
+      this.storages[storage.name] = storage
     }
+    return storage
   }
 
-  addModel(modelClass) {
-    if (Model.isPrototypeOf(modelClass)) {
-      modelClass.app = this
-      this.models[modelClass.name] = modelClass
-    } else {
-      throw new Error(`Invalid model class: ${modelClass}`)
-    }
-  }
-
-  sortModels(models) {
-    const sortByRelations = (list, collected = {}, excluded = {}) => {
-      for (const modelClass of list) {
-        const { name } = modelClass
-        if (!collected[name] && !excluded[name]) {
-          for (const relation of Object.values(modelClass.getRelations())) {
-            if (!(relation instanceof BelongsToOneRelation)) {
-              const { relatedModelClass, joinTableModelClass } = relation
-              for (const related of [joinTableModelClass, relatedModelClass]) {
-                // Exclude self-references and generated join models:
-                if (related && related !== modelClass && models[related.name]) {
-                  sortByRelations([related], collected, {
-                    // Exclude modelClass to prevent endless recursions:
-                    [name]: modelClass,
-                    ...excluded
-                  })
-                }
-              }
-            }
-          }
-          collected[name] = modelClass
-        }
-      }
-      return Object.values(collected)
-    }
-    // Return a new object with the sorted models as its key/value pairs.
-    // NOTE: We need to reverse for the above algorithm to sort properly,
-    // and then reverse the result back.
-    return sortByRelations(Object.values(models).reverse()).reverse().reduce(
-      (models, modelClass) => {
-        models[modelClass.name] = modelClass
-        return models
-      },
-      Object.create(null)
-    )
+  addStorages(storages) {
+    for (const [name, config] of Object.entries(storages)) {
+      this.addStorage(config, name)
+    }
   }
 
-  getModel(name) {
-    return (
-      this.models[name] ||
-      !name.endsWith('Model') && this.models[`${name}Model`] ||
-      null
+  async setupStorages() {
+    await Promise.all(Object.values(this.storages)
+      .filter(storage => !storage.initialized)
+      .map(async storage => {
+        // Different from models, services and controllers, storages can have
+        // async `setup()` methods, as used by `S3Storage`.
+        await storage.setup()
+        await storage.initialize()
+        storage.initialized = true
+      })
     )
   }
 
-  findModel(callback) {
-    return Object.values(this.models).find(callback)
+  getService(name) {
+    return this.services[name] || null
   }
 
-  addServices(services) {
-    for (const [name, service] of Object.entries(services)) {
-      this.addService(service, name)
-    }
+  findService(callback) {
+    return Object.values(this.services).find(callback) || null
   }
 
   addService(service, name) {
@@ -259,40 +197,126 @@ export class Application extends Koa {
     if (!(service instanceof Service)) {
       throw new Error(`Invalid service: ${service}`)
     }
-    // Only after the constructor is called, `service.name` is guaranteed to be
-    // set to the correct value, e.g. with an after-constructor class property.
-    ({ name } = service)
-    const config = this.config.services[name]
-    if (config === undefined) {
-      throw new Error(`Configuration missing for service '${name}'`)
-    }
-    // As a convention, the configuration of a service can be set to `false`
-    // in order to entirely deactivate the service.
-    if (config !== false) {
-      service.setup(config)
-      this.services[name] = service
-      // Now that the service is set up, call `initialize()` which can be
-      // overridden by services.
-      service.initialize()
+    this.services[service.name] = service
+  }
+
+  addServices(services) {
+    for (const [name, service] of Object.entries(services)) {
+      this.addService(service, name)
     }
   }
 
-  getService(name) {
-    return this.services[name] || null
+  async setupServices() {
+    await Promise.all(Object.values(this.services)
+      .filter(service => !service.initialized)
+      .map(async service => {
+        const { name } = service
+        const config = this.config.services[name]
+        if (config === undefined) {
+          throw new Error(`Configuration missing for service '${name}'`)
+        }
+        // As a convention, the configuration of a service can be set to `false`
+        // in order to entirely deactivate the service.
+        if (config === false) {
+          delete this.services[name]
+        } else {
+          service.setup(config)
+          await service.initialize()
+          service.initialized = true
+        }
+      })
+    )
   }
 
-  findService(callback) {
-    return Object.values(this.services).find(callback)
+  getModel(name) {
+    return (
+      this.models[name] ||
+      !name.endsWith('Model') && this.models[`${name}Model`] ||
+      null
+    )
   }
 
-  addControllers(controllers, namespace) {
-    for (const [key, value] of Object.entries(controllers)) {
-      if (isModule(value) || isPlainObject(value)) {
-        this.addControllers(value, namespace ? `${namespace}/${key}` : key)
+  findModel(callback) {
+    return Object.values(this.models).find(callback) || null
+  }
+
+  addModel(modelClass) {
+    this.addModels([modelClass])
+  }
+
+  addModels(models) {
+    models = Object.values(models)
+    // First, add all models to the application, so that they can be referenced
+    // by other models, e.g. in `jsonSchema` and  `relationMappings`:
+    for (const modelClass of models) {
+      if (Model.isPrototypeOf(modelClass)) {
+        this.models[modelClass.name] = modelClass
       } else {
-        this.addController(value, namespace)
+        throw new Error(`Invalid model class: ${modelClass}`)
       }
     }
+    // Then, configure all models and add their schemas to the validator:
+    for (const modelClass of models) {
+      modelClass.configure(this)
+      this.validator.addSchema(modelClass.getJsonSchema())
+    }
+    this.logModels(models)
+  }
+
+  async setupModels() {
+    await Promise.all(Object.values(this.models)
+      .filter(modelClass => !modelClass.initialized)
+      .map(async modelClass => {
+        // While `setup()` is used for internal dito things, `initialize()` is
+        // called async and meant to be used by the user, without the need to
+        // call `super.initialize()`.
+        modelClass.setup()
+        await modelClass.initialize()
+        modelClass.initialized = true
+      })
+    )
+  }
+
+  logModels(models) {
+    const { log } = this.config
+    if (log.schema || log.relations) {
+      for (const modelClass of models) {
+        const shouldLog = option => (
+          option === true ||
+          asArray(option).includes(modelClass.name)
+        )
+        const data = {}
+        if (shouldLog(log.schema)) {
+          data.schema = modelClass.getJsonSchema()
+        }
+        if (shouldLog(log.relations)) {
+          data.relations = clone(
+            modelClass.getRelationMappings(),
+            value => Model.isPrototypeOf(value)
+              ? `[Model: ${value.name}]`
+              : value
+          )
+        }
+        if (Object.keys(data).length > 0) {
+          console.info(
+            pico.yellow(pico.bold(`\n${modelClass.name}:\n`)),
+            util.inspect(data, {
+              colors: true,
+              depth: null,
+              maxArrayLength: null
+            })
+          )
+        }
+      }
+    }
+  }
+
+  getController(url) {
+    return this.controllers[url] || null
+  }
+
+  findController(callback) {
+    return Object.values(this.controllers).find(callback) || null
   }
 
   addController(controller, namespace) {
@@ -305,26 +329,36 @@ export class Application extends Koa {
       throw new Error(`Invalid controller: ${controller}`)
     }
     // Inheritance of action methods cannot happen in the constructor itself,
-    // so call separate `setup()` method after in order to take care of it.
-    controller.setup()
+    // so call separate `configure()` method after in order to take care of it.
+    controller.configure()
     this.controllers[controller.url] = controller
-    // Now that the controller is set up, call `initialize()` which can be
-    // overridden by controllers.
-    controller.initialize()
-    // Each controller can also compose their own middleware (or app), e.g. as
-    // used in `AdminController`:
-    const composed = controller.compose()
-    if (composed) {
-      this.use(mount(controller.url, composed))
-    }
   }
 
-  getController(url) {
-    return this.controllers[url] || null
+  addControllers(controllers, namespace) {
+    for (const [key, value] of Object.entries(controllers)) {
+      if (isModule(value) || isPlainObject(value)) {
+        this.addControllers(value, namespace ? `${namespace}/${key}` : key)
+      } else {
+        this.addController(value, namespace)
+      }
+    }
   }
 
-  findController(callback) {
-    return Object.values(this.controllers).find(callback)
+  async setupControllers() {
+    await Promise.all(Object.values(this.controllers)
+      .filter(controller => !controller.initialized)
+      .map(async controller => {
+        controller.setup()
+        await controller.initialize()
+        // Each controller can also compose their own middleware (or app), e.g.
+        // as used in `AdminController`:
+        const composed = controller.compose()
+        if (composed) {
+          this.use(mount(controller.url, composed))
+        }
+        controller.initialized = true
+      })
+    )
   }
 
   getAdminController() {
@@ -377,37 +411,6 @@ export class Application extends Koa {
     return assetConfig
   }
 
-  addStorages(storages) {
-    for (const [name, config] of Object.entries(storages)) {
-      this.addStorage(config, name)
-    }
-  }
-
-  addStorage(config, name) {
-    let storage = null
-    if (isPlainObject(config)) {
-      const storageClass = Storage.get(config.type)
-      if (!storageClass) {
-        throw new Error(`Unsupported storage: ${config}`)
-      }
-      // eslint-disable-next-line new-cap
-      storage = new storageClass(this, config)
-    } else if (config instanceof Storage) {
-      storage = config
-    }
-    if (storage) {
-      if (name) {
-        storage.name = name
-      }
-      this.storages[storage.name] = storage
-    }
-    return storage
-  }
-
-  getStorage(name) {
-    return this.storages[name] || null
-  }
-
   compileValidator(jsonSchema, options) {
     return jsonSchema
       ? this.validator.compile(jsonSchema, options)
@@ -715,6 +718,10 @@ export class Application extends Koa {
     if (this.config.log.errors !== false) {
       this.on('error', this.logError)
     }
+    // It's ok to call this multiple times, because only the entries in the
+    // registres (storages, services, models, controllers) that weren't
+    // initialized yet will be initialized.
+    await this.setup()
     await this.emit('before:start')
     this.server = await new Promise(resolve => {
       const server = this.listen(this.config.server, () => {
@@ -771,7 +778,7 @@ export class Application extends Koa {
     }
   }
 
-  async startOrExit() {
+  async execute() {
     try {
       await this.start()
     } catch (err) {
@@ -780,6 +787,11 @@ export class Application extends Koa {
     }
   }
 
+  startOrExit() {
+    deprecate(`app.startOrExit() is deprecated. Call app.execute() instead.`)
+    return this.execute()
+  }
+
   // Assets handling
 
   async createAssets(storage, files, count = 0, trx = null) {

package/src/controllers/CollectionController.js

@@ -4,27 +4,31 @@ import { ControllerError } from '../errors/index.js'
 
 // Abstract base class for ModelController and RelationController
 export class CollectionController extends Controller {
-  constructor(app, namespace) {
-    super(app, namespace)
-    this.modelClass = null // To be defined by sub-classes
-    this.isOneToOne = false
-    this.relate = false
-    this.unrelate = false
-  }
+  graph = false
+  scope = null
+  relate = false
+  unrelate = false
+  modelClass = null // To be defined by sub-classes
+  isOneToOne = false
+  idParam = null
+  idValidator = null
 
-  setup(isRoot) {
-    super.setup(isRoot, false)
+  // @override
+  configure() {
+    super.configure()
     this.idParam = this.level ? `id${this.level}` : 'id'
-    this.graph = !!this.graph
-    this.transacted = !!this.transacted
-    this.scope = this.scope || null
-    this.collection = this.setupActions('collection')
-    this.member = this.isOneToOne ? {} : this.setupActions('member')
     // Create a dummy model instance to validate the requested id against.
     // eslint-disable-next-line new-cap
     this.idValidator = new this.modelClass()
   }
 
+  // @override
+  setup() {
+    this.collection = this.setupActions('collection')
+    this.member = this.isOneToOne ? {} : this.setupActions('member')
+    this.assets = this.setupAssets()
+  }
+
   // @override
   setupAssets() {
     const { modelClass } = this

package/src/controllers/Controller.js

@@ -15,36 +15,35 @@ import {
 } from '@ditojs/utils'
 
 export class Controller {
+  name = null
+  path = null
+  url = null
+  actions = null
+  assets = null
+  transacted = false
+  initialized = false
+
   constructor(app, namespace) {
     this.app = app
-    this.namespace = this.namespace || namespace
+    this.namespace = namespace
     this.logging = this.app.config.log.routes
     this.level = 0
   }
 
+  // `configure()` is called right after the constructor, but before `setup()`
+  // which sets up the actions and routes, and the custom `async initialize()`.
   // @overridable
-  initialize() {
-  }
-
-  // @return {Application|Function} [app or function]
-  compose() {
-    // To be overridden in sub-classes, if the controller needs to install
-    // middleware. For normal routes, use `this.app.addRoute()` instead.
-  }
-
-  setup(isRoot = true, setupActionsObject = true) {
-    this._setupEmitter(this.hooks, {
+  configure() {
+    this._configureEmitter(this.hooks, {
       // Support wildcard hooks only on controllers:
       wildcard: true
     })
     // If the class name ends in 'Controller', remove it from controller name.
-    this.name = this.name ||
-      this.constructor.name.match(/^(.*?)(?:Controller|)$/)[1]
-    if (this.path === undefined) {
-      this.path = this.app.normalizePath(this.name)
-    }
-    this.transacted = !!this.transacted
-    if (isRoot) {
+    this.name ||= this.constructor.name.match(/^(.*?)(?:Controller|)$/)[1]
+    this.path ??= this.app.normalizePath(this.name)
+    if (!this.url) {
+      // NOTE: `RelationController.configure()` sets the `url` before calling
+      // `super.configure()` and has its own handling of logging.
       const { path, namespace } = this
       // TODO: The distinction between  `url` and `path` is a bit tricky, since
       // what we call `url` here is called `path` in Router, and may contain
@@ -61,16 +60,30 @@ export class Controller {
         }`,
         this.level
       )
-      if (setupActionsObject) {
-        this.actions = this.actions || this.reflectActionsObject()
-        // Now that the instance fields are reflected in the `controller` object
-        // we can use the normal inheritance mechanism through `setupActions()`:
-        this.actions = this.setupActions('actions')
-      }
-      this.assets = this.setupAssets()
     }
   }
 
+  // @overridable
+  setup() {
+    this.actions ||= this.reflectActionsObject()
+    // Now that the instance fields are reflected in the `controller` object
+    // we can use the normal inheritance mechanism through `setupActions()`:
+    this.actions = this.setupActions('actions')
+    this.assets = this.setupAssets()
+  }
+
+  // @overridable
+  async initialize() {
+    // To be overridden in sub-classes, if the controller needs to initialize.
+  }
+
+  // @return {Application|Function} [app or function]
+  // @overridable
+  compose() {
+    // To be overridden in sub-classes, if the controller needs to install
+    // middleware. For normal routes, use `this.app.addRoute()` instead.
+  }
+
   reflectActionsObject() {
     // On base controllers, the actions can be defined directly in the class
     // instead of inside an actions object, as is done with model and relation
@@ -78,7 +91,7 @@ export class Controller {
     // these other controllers, we reflect these instance fields in a separate
     // `actions` object.
     const { allow } = this
-    const controller = allow ? { allow } : {}
+    const actions = allow ? { allow } : {}
 
     const addAction = key => {
       const value = this[key]
@@ -86,7 +99,7 @@ export class Controller {
       // in turn sets the `method` property on the method, as well as action
       // objects which provide the `method` property:
       if (value?.method) {
-        controller[key] = value
+        actions[key] = value
       }
     }
     // Use `Object.getOwnPropertyNames()` to get the fields, in order to
@@ -95,7 +108,7 @@ export class Controller {
     const proto = Object.getPrototypeOf(this)
     Object.getOwnPropertyNames(proto).forEach(addAction)
     Object.getOwnPropertyNames(this).forEach(addAction)
-    return controller
+    return actions
   }
 
   setupRoute(method, url, transacted, authorize, action, middlewares) {

package/src/controllers/ModelController.js

@@ -6,10 +6,14 @@ import { ControllerError } from '../errors/index.js'
 import { setupPropertyInheritance } from '../utils/index.js'
 
 export class ModelController extends CollectionController {
-  setup() {
-    super.setup(true)
-    this.modelClass = this.modelClass ||
+  configure() {
+    super.configure()
+    this.modelClass ||=
       this.app.models[camelize(pluralize.singular(this.name), true)]
+  }
+
+  setup() {
+    super.setup()
     this.relations = this.setupRelations()
   }
 
@@ -36,9 +40,14 @@ export class ModelController extends CollectionController {
     if (!relationInstance || !relationDefinition) {
       throw new ControllerError(this, `Relation '${name}' not found.`)
     }
-    return new RelationController(
+    const relation = new RelationController(
       this, object, relationInstance, relationDefinition
     )
+    // RelationController instances are not registered with the app, but are
+    // manged by their parent controller instead.
+    relation.configure()
+    relation.setup()
+    return relation
   }
 
   // @override

package/src/controllers/RelationController.js

@@ -29,10 +29,6 @@ export class RelationController extends CollectionController {
       // relations:
       this.scope = asArray(parent.scope).filter(scope => getScope(scope).graph)
     }
-    // Initialize:
-    this.path = this.app.normalizePath(this.name)
-    this.url = `${this.parent.url}/${this.parent.getPath('member', this.path)}`
-    this.log(`${pico.blue(this.path)}${pico.white(':')}`, this.level)
     // Copy over all fields in the relation object except the ones that are
     // going to be inherited in `setup()` (relation, member, allow), for
     // settings like scope, etc.
@@ -41,7 +37,15 @@ export class RelationController extends CollectionController {
         this[key] = this.object[key]
       }
     }
-    this.setup(false)
+  }
+
+  // @override
+  configure() {
+    // Setup the `url` before calling `super.configure()` to override its
+    // default behavior for `RelationController`:
+    this.url = `${this.parent.url}/${this.parent.getPath('member', this.path)}`
+    this.log(`${pico.blue(this.path)}${pico.white(':')}`, this.level)
+    super.configure()
   }
 
   // @override

package/src/lib/EventEmitter.js

@@ -3,7 +3,7 @@ import { isPlainObject, isString, isArray, asArray } from '@ditojs/utils'
 
 export class EventEmitter extends EventEmitter2 {
   // Method for classes that use `EventEmitter.mixin()` to setup the emitter.
-  _setupEmitter(events, options) {
+  _configureEmitter(events, options) {
     EventEmitter2.call(this, {
       delimiter: ':',
       maxListeners: 0,

package/src/mixins/UserMixin.js

@@ -68,8 +68,7 @@ export const UserMixin = mixin(Model => class extends Model {
     return this.$is(ctx.state.user)
   }
 
-  static initialize() {
-    super.initialize()
+  static setup() {
     userClasses[this.name] = this
     const {
       usernameProperty,

package/src/models/Model.js

@@ -23,6 +23,10 @@ import RelationAccessor from './RelationAccessor.js'
 import definitions from './definitions/index.js'
 
 export class Model extends objection.Model {
+  static app = null // Set by `Application.addModel()`
+  static initialized = false
+  static referenceValidator = null
+
   // Define a default constructor to allow new Model(json) as a short-cut to
   // `Model.fromJson(json, { skipValidation: true })`
   constructor(json) {
@@ -32,19 +36,24 @@ export class Model extends objection.Model {
     }
   }
 
-  static setup(knex) {
-    this.knex(knex)
+  static configure(app) {
+    this.app = app
+    this.knex(app.knex)
+    const { hooks, assets } = this.definition
+    this._configureEmitter(hooks)
+    if (assets) {
+      this._configureAssetsEvents(assets)
+    }
     try {
       for (const relation of Object.values(this.getRelations())) {
-        this.setupRelation(relation)
+        this._configureRelation(relation)
       }
     } catch (error) {
       throw error instanceof RelationError ? error : new RelationError(error)
     }
-    this.referenceValidator = null
   }
 
-  static setupRelation(relation) {
+  static _configureRelation(relation) {
     // Add this relation to the related model's relatedRelations, so it can
     // register all required foreign keys in its properties.
     relation.relatedModelClass.getRelatedRelations().push(relation)
@@ -87,13 +96,12 @@ export class Model extends objection.Model {
     defineAccessor(this.prototype, false)
   }
 
+  // @overridable
+  static setup() {
+  }
+
   // @overridable
   static initialize() {
-    const { hooks, assets } = this.definition
-    this._setupEmitter(hooks)
-    if (assets) {
-      this._setupAssetsEvents(assets)
-    }
   }
 
   // @overridable
@@ -900,7 +908,7 @@ export class Model extends objection.Model {
 
   // Assets handling
 
-  static _setupAssetsEvents(assets) {
+  static _configureAssetsEvents(assets) {
     const assetDataPaths = Object.keys(assets)
 
     this.on([

package/src/query/QueryBuilder.js

@@ -167,7 +167,7 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   allowScope(...scopes) {
-    this._allowScopes = this._allowScopes || {
+    this._allowScopes ||= {
       default: true // The default scope is always allowed.
     }
     for (const expr of scopes) {
@@ -279,7 +279,7 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   allowFilter(...filters) {
-    this._allowFilters = this._allowFilters || {}
+    this._allowFilters ||= {}
     for (const filter of filters) {
       this._allowFilters[filter] = true
     }

package/src/services/Service.js

@@ -1,6 +1,8 @@
 import { camelize } from '@ditojs/utils'
 
 export class Service {
+  initialized = false
+
   constructor(app, name) {
     this.app = app
     this.name = camelize(
@@ -16,7 +18,7 @@ export class Service {
   }
 
   // @overridable
-  initialize() {
+  async initialize() {
   }
 
   // @overridable
@@ -34,7 +36,7 @@ export class Service {
 
   get logger() {
     const value = this.getLogger()
-    Object.defineProperties(this, 'logger', { value })
+    Object.defineProperty(this, 'logger', { value })
     return value
   }
 }

package/src/storage/DiskStorage.js

@@ -6,12 +6,10 @@ import { Storage } from './Storage.js'
 export class DiskStorage extends Storage {
   static type = 'disk'
 
-  constructor(app, config) {
-    super(app, config)
+  setup() {
     if (!this.path) {
       throw new Error(`Missing configuration (path) for storage ${this.name}`)
     }
-
     this.storage = multer.diskStorage({
       destination: (req, storageFile, cb) => {
         // Add `storageFile.key` property to internal storage file object.

package/src/storage/S3Storage.js

@@ -1,4 +1,3 @@
-import { S3 } from '@aws-sdk/client-s3'
 import multerS3 from 'multer-s3'
 import { fileTypeFromBuffer } from 'file-type'
 import isSvg from 'is-svg'
@@ -9,15 +8,22 @@ import consumers from 'stream/consumers'
 export class S3Storage extends Storage {
   static type = 's3'
 
-  constructor(app, config) {
-    super(app, config)
+  s3 = null
+  acl = null
+  bucket = null
+
+  async setup() {
     const {
       name,
       s3,
       acl,
       bucket,
       ...options
-    } = config
+    } = this.config
+
+    // "@aws-sdk/client-s3" is a peer-dependency, and importing it costly,
+    // so we do it lazily.
+    const { S3 } = await import('@aws-sdk/client-s3')
     this.s3 = new S3(s3)
     this.acl = acl
     this.bucket = bucket

package/src/storage/Storage.js

@@ -10,6 +10,8 @@ import { AssetFile } from './AssetFile.js'
 const storageClasses = {}
 
 export class Storage {
+  initialized = false
+
   constructor(app, config) {
     this.app = app
     this.config = config
@@ -20,6 +22,14 @@ export class Storage {
     this.storage = null
   }
 
+  // @overridable
+  async setup() {
+  }
+
+  // @overridable
+  async initialize() {
+  }
+
   static register(storageClass) {
     const type = (
       storageClass.type ||

package/types/index.d.ts

@@ -27,11 +27,13 @@ import {
   Class,
   ConditionalExcept,
   ConditionalKeys,
-  Constructor, SetOptional, SetReturnType
+  Constructor,
+  SetOptional,
+  SetReturnType
 } from 'type-fest'
 import { UserConfig } from 'vite'
 
-export type Page<$Model extends Model> = {
+export type Page<$Model extends Model = Model> = {
   total: number
   results: $Model[]
 }
@@ -357,14 +359,14 @@ export interface ApiConfig {
 
 export interface ApplicationControllers {
   [k: string]:
-    | Class<ModelController<Model>>
+    | Class<ModelController>
     | Class<Controller>
     | ApplicationControllers
 }
 
 export type Models = Record<string, Class<Model>>
 
-export class Application<$Models extends Models> {
+export class Application<$Models extends Models = Models> {
   constructor(options: {
     config?: ApplicationConfig
     validator?: Validator
@@ -383,17 +385,22 @@ export class Application<$Models extends Models> {
   })
 
   models: $Models
+  setup(): Promise<void>
+  execute(): Promise<void>
   start(): Promise<void>
   stop(timeout?: number): Promise<void>
-  startOrExit(): Promise<void>
-  addServices(services: Services): void
+  addStorage(storage: StorageConfig): void
+  addStorages(storages: StorageConfigs): void
+  setupStorages(): Promise<void>
   addService(service: Service): void
+  addServices(services: Services): void
+  setupServices(): Promise<void>
+  addModel(model: Class<Model>): void
+  addModels(models: Models): void
+  setupModels(): Promise<void>
   addController(controllers: Controller, namespace?: string): void
   addControllers(controllers: ApplicationControllers, namespace?: string): void
-  addStorages(storages: StorageConfigs): void
-  addStorage(storage: StorageConfig): void
-  addModels(models: Models): void
-  addModel(model: Class<Model>): void
+  setupControllers(): Promise<void>
   getAdminViteConfig(config?: UserConfig): UserConfig
 }
 export interface Application
@@ -564,23 +571,23 @@ export type ModelProperty<T = any> = Schema<T> & {
   hidden?: boolean
 }
 
-export type ModelScope<$Model extends Model> = (
+export type ModelScope<$Model extends Model = Model> = (
   this: $Model,
   query: QueryBuilder<$Model>,
   applyParentScope: (query: QueryBuilder<$Model>) => QueryBuilder<$Model>
 ) => QueryBuilder<$Model, any> | void
 
-export type ModelScopes<$Model extends Model> = Record<
+export type ModelScopes<$Model extends Model = Model> = Record<
   string,
   ModelScope<$Model>
 >
 
-export type ModelFilterFunction<$Model extends Model> = (
+export type ModelFilterFunction<$Model extends Model = Model> = (
   queryBuilder: QueryBuilder<$Model>,
   ...args: any[]
 ) => void
 
-export type ModelFilter<$Model extends Model> =
+export type ModelFilter<$Model extends Model = Model> =
   | {
       filter: 'text' | 'date-range'
       properties?: string[]
@@ -593,7 +600,7 @@ export type ModelFilter<$Model extends Model> =
     }
   | ModelFilterFunction<$Model>
 
-export type ModelFilters<$Model extends Model> = Record<
+export type ModelFilters<$Model extends Model = Model> = Record<
   string,
   ModelFilter<$Model>
 >
@@ -614,7 +621,8 @@ export interface ModelOptions extends objection.ModelOptions {
 type ModelHookFunction<$Model extends Model> = (
   args: objection.StaticHookArguments<$Model>
 ) => void
-export type ModelHooks<$Model extends Model> = {
+
+export type ModelHooks<$Model extends Model = Model> = {
   [key in `${'before' | 'after'}:${
     | 'find'
     | 'insert'
@@ -823,7 +831,7 @@ export type ModelRelations = Record<string, ModelRelation>
 
 export type ModelProperties = Record<string, ModelProperty>
 
-export type ControllerAction<$Controller extends Controller> =
+export type ControllerAction<$Controller extends Controller = Controller> =
   | ControllerActionOptions<$Controller>
   | ControllerActionHandler<$Controller>
 
@@ -860,11 +868,12 @@ export class Controller {
   authorize?: Authorize
   actions?: ControllerActions<this>
 
+  configure(): void
+  setup(): void
   initialize(): void
-  setup(isRoot: boolean, setupActionsObject: boolean): void
   // TODO: type reflectActionsObject
   reflectActionsObject(): any
-  setupRoute<$ControllerAction extends ControllerAction<any>>(
+  setupRoute<$ControllerAction extends ControllerAction = ControllerAction>(
     method: HTTPMethod,
     url: string,
     transacted: boolean,
@@ -915,14 +924,12 @@ export class Controller {
 export type ActionParameter = Schema & { name: string }
 
 export type ModelControllerActionHandler<
-  $ModelController extends ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = (this: $ModelController, ctx: KoaContext, ...args: any[]) => any
 
-export type ControllerActionHandler<$Controller extends Controller> = (
-  this: $Controller,
-  ctx: KoaContext,
-  ...args: any[]
-) => any
+export type ControllerActionHandler<
+  $Controller extends Controller = Controller
+> = (this: $Controller, ctx: KoaContext, ...args: any[]) => any
 
 export type ExtractModelProperties<$Model> = {
   [$Key in SelectModelPropertyKeys<$Model>]: $Model[$Key] extends Model
@@ -1005,19 +1012,20 @@ export type BaseControllerActionOptions = {
   transacted?: boolean
 }
 
-export type ControllerActionOptions<$Controller extends Controller> =
-  BaseControllerActionOptions & {
-    handler: ControllerActionHandler<$Controller>
-  }
+export type ControllerActionOptions<
+  $Controller extends Controller = Controller
+> = BaseControllerActionOptions & {
+  handler: ControllerActionHandler<$Controller>
+}
 
 export type ModelControllerActionOptions<
-  $ModelController extends ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = BaseControllerActionOptions & {
   /** The function to be called when the action route is requested. */
   handler: ModelControllerActionHandler<$ModelController>
 }
 
-export type MemberActionParameter<M extends Model> =
+export type MemberActionParameter<$Model extends Model = Model> =
   | Schema
   | {
       member: true
@@ -1037,17 +1045,17 @@ export type MemberActionParameter<M extends Model> =
        */
       forUpdate?: boolean
       /** Modify the member query. */
-      modify?: (query: QueryBuilder<M>) => QueryBuilder<M>
+      modify?: (query: QueryBuilder<$Model>) => QueryBuilder<$Model>
     }
 
 export type ModelControllerAction<
-  $ModelController extends ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > =
   | ModelControllerActionOptions<$ModelController>
   | ModelControllerActionHandler<$ModelController>
 
 export type ModelControllerActions<
-  $ModelController extends ModelController<Model> = ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = {
   [name: ControllerActionName]: ModelControllerAction<$ModelController>
   allow?: OrReadOnly<ControllerActionName[]>
@@ -1055,19 +1063,19 @@ export type ModelControllerActions<
 }
 
 type ModelControllerMemberAction<
-  $ModelController extends ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > =
   | (Omit<ModelControllerActionOptions<$ModelController>, 'parameters'> & {
       parameters?: {
         [key: string]: MemberActionParameter<
-          modelFromModelController<$ModelController>
+          ModelFromModelController<$ModelController>
         >
       }
     })
   | ModelControllerActionHandler<$ModelController>
 
 export type ModelControllerMemberActions<
-  $ModelController extends ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = {
   [name: ControllerActionName]: ModelControllerMemberAction<$ModelController>
   allow?: OrReadOnly<ControllerActionName[]>
@@ -1076,7 +1084,7 @@ export type ModelControllerMemberActions<
 
 export type ControllerActionName = `${HTTPMethod}${string}`
 
-export type ControllerActions<$Controller extends Controller> = {
+export type ControllerActions<$Controller extends Controller = Controller> = {
   [name: ControllerActionName]: ControllerAction<$Controller>
   allow?: OrReadOnly<ControllerActionName[]>
   authorize?: Authorize
@@ -1110,15 +1118,15 @@ type ModelControllerHookKeys<
   | ControllerActionName
   | '*'}`
 type ModelControllerHook<
-  $ModelController extends ModelController<Model> = ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = (
   ctx: KoaContext,
-  result: objection.Page<modelFromModelController<$ModelController>>
+  result: objection.Page<ModelFromModelController<$ModelController>>
 ) => any
 
 type HookHandler = () => void
 
-type HookKeysFromController<$ModelController extends ModelController<Model>> =
+type HookKeysFromController<$ModelController extends ModelController> =
   | ModelControllerHookKeys<
       Exclude<
         keyof Exclude<$ModelController['collection'], undefined>,
@@ -1135,7 +1143,7 @@ type HookKeysFromController<$ModelController extends ModelController<Model>> =
     >
 
 type HandlerFromHookKey<
-  $ModelController extends ModelController<Model>,
+  $ModelController extends ModelController,
   $Key extends HookKeysFromController<$ModelController>
 > = $Key extends `${'before' | 'after' | '*'}:${
   | 'collection'
@@ -1145,7 +1153,7 @@ type HandlerFromHookKey<
   : never
 
 type ModelControllerHooks<
-  $ModelController extends ModelController<Model> = ModelController<Model>
+  $ModelController extends ModelController = ModelController
 > = {
   [$Key in HookKeysFromController<$ModelController>]?: HandlerFromHookKey<
     $ModelController,
@@ -1428,13 +1436,9 @@ export type QueryParameterOptionKey = keyof QueryParameterOptions
 
 export class Service {
   constructor(app: Application<Models>, name?: string)
-
   setup(config: any): void
-
   initialize(): void
-
   start(): Promise<void>
-
   stop(): Promise<void>
 }
 export type Services = Record<string, Class<Service> | Service>
@@ -1853,7 +1857,7 @@ type OrReadOnly<T> = Readonly<T> | T
 
 type OrPromiseOf<T> = Promise<T> | T
 
-type modelFromModelController<$ModelController extends ModelController<Model>> =
+type ModelFromModelController<$ModelController extends ModelController> =
   InstanceType<Exclude<$ModelController['modelClass'], undefined>>
 
 export type SelectModelProperties<T> = {