@ditojs/server 1.13.0 → 1.14.0

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 ||