adapt-authoring-core 1.4.3 → 1.6.0

package/conf/config.schema.json

@@ -7,6 +7,12 @@
       "type": "boolean",
       "default": true
     },
+    "moduleLoadTimeout": {
+      "description": "Amount of time to wait for a module to load before erroring",
+      "type": "string",
+      "isTimeMs": true,
+      "default": "1m"
+    },
     "dataDir": {
       "description": "Directory for persistant application data",
       "type": "string",

package/docs/plugins/index-manual.js

@@ -18,7 +18,7 @@ export default class Contributors {
     this.tiers = [
       { name: 'gold', count: 3, border: '#FFD700' },
       { name: 'silver', count: 6, border: '#C0C0C0' },
-      { name: 'bronze', count: 10, border: '#CD7F32' },
+      { name: 'bronze', count: 9, border: '#CD7F32' },
       { name: 'contributor' }
     ]
   }

package/lib/AbstractModule.js

@@ -71,13 +71,12 @@ class AbstractModule {
     if (this._isReady) {
       return
     }
-    await this.readyHook.invoke(error)
-    if (error) {
-      return
+    if (!error) {
+      this._isReady = true
     }
-    this._isReady = true
     this.initTime = Math.round((Date.now() - this._startTime))
     this.log('verbose', AbstractModule.MODULE_READY, this.initTime)
+    await this.readyHook.invoke(error)
   }
 
   /**

package/lib/App.js

@@ -70,7 +70,9 @@ class App extends AbstractModule {
     if (failedMods.length) this.log('warn', `${failedMods.length} module${failedMods.length === 1 ? '' : 's'} failed to load: ${failedMods}. See above for details`)
     if (startError) {
       process.exitCode = 1
-      throw new Error('Failed to start App')
+      const e = new Error('Failed to start App')
+      e.cause = startError
+      throw e
     }
   }
 

package/lib/DependencyLoader.js

@@ -11,14 +11,15 @@ import Utils from './Utils.js'
  */
 class DependencyLoader {
   /**
-   * @param {Object} app The main app instance
+   * Creates a new DependencyLoader instance
+   * @param {App} app The main app instance
    */
   constructor (app) {
     /**
-     * Name of the class (onvenience function to stay consistent with other classes)
-     * @type {String}
+     * Name of the class (convenience function to stay consistent with other classes)
+     * @type {string}
      */
-    this.name = this.constructor.name
+    this.name = this.constructor.name.toLowerCase()
     /**
      * Reference to the main app
      * @type {App}
@@ -26,22 +27,22 @@ class DependencyLoader {
     this.app = app
     /**
      * Key/value store of all the Adapt dependencies' configs. Note this includes dependencies which are not loaded as Adapt modules (i.e. `module: false`).
-     * @type {Object}
+     * @type {Object<string, Object>}
      */
     this.configs = {}
     /**
-     * List of dependency instances
-     * @type {object}
+     * Map of module names to their loaded instances
+     * @type {Object<string, Object>}
      */
     this.instances = {}
     /**
-     * Peer dependencies listed for each dependency
-     * @type {object}
+     * Map of module names to arrays of modules that depend on them as peer dependencies
+     * @type {Object<string, Array<string>>}
      */
     this.peerDependencies = {}
     /**
-     * List of modules which have failed to load
-     * @type {Array}
+     * List of module names which have failed to load
+     * @type {Array<string>}
      */
     this.failedModules = []
     /**
@@ -54,11 +55,14 @@ class DependencyLoader {
      * @type {Hook}
      */
     this.moduleLoadedHook = new Hook()
+
+    this.moduleLoadedHook.tap(this.logProgress, this)
   }
 
   /**
-   * Loads all Adapt module dependencies
-   * @return {Promise}
+   * Loads all Adapt module dependencies. Essential modules are loaded first, then non-essential modules (with force mode).
+   * @return {Promise<void>}
+   * @throws {Error} When any essential module fails to load
    */
   async load () {
     await this.loadConfigs()
@@ -71,9 +75,7 @@ class DependencyLoader {
     }, { essential: [], theRest: [] })
     // load each set of deps
     await this.loadModules(essential)
-    try {
-      await this.loadModules(theRest)
-    } catch (e) {} // not a problem if non-essential module fails to load
+    await this.loadModules(theRest, { force: true })
 
     if (this.failedModules.length) {
       throw new Error(`Failed to load modules ${this.failedModules.join(', ')}`)
@@ -81,8 +83,8 @@ class DependencyLoader {
   }
 
   /**
-   * Loads configs for all dependencies
-   * @return {Promise}
+   * Loads configuration files for all Adapt dependencies found in node_modules.
+   * @return {Promise<void>}
    */
   async loadConfigs () {
     /** @ignore */ this._configsLoaded = false
@@ -117,9 +119,9 @@ class DependencyLoader {
   }
 
   /**
-   * Loads the relevant configuration files for an Adapt module
-   * @param {String} modDir Module directory
-   * @return {Promise}
+   * Loads the relevant configuration files for an Adapt module by reading and merging package.json and adapt.json
+   * @param {string} modDir Absolute path to the module directory
+   * @return {Promise<Object>} Resolves with configuration object
    */
   async loadModuleConfig (modDir) {
     return {
@@ -130,9 +132,10 @@ class DependencyLoader {
   }
 
   /**
-   * Loads a single Adapt module. Should not need to be called directly.
-   * @param {String} modName Name of the module to load
-   * @return {Promise} Resolves with module instance on module.onReady
+   * Loads a single Adapt module by dynamically importing it, instantiating it, and waiting for its onReady promise. Should not need to be called directly.
+   * @param {string} modName Name of the module to load (e.g., 'adapt-authoring-core')
+   * @return {Promise<Object>} Resolves with module instance when module.onReady completes
+   * @throws {Error} When module already exists, is in an unknown format or cannot be initialised (or initialisation exceeds 60 second timeout)
    */
   async loadModule (modName) {
     if (this.instances[modName]) {
@@ -154,9 +157,11 @@ class DependencyLoader {
       throw new Error('Module must define onReady function')
     }
     try {
+      // all essential modules will use hard-coded value, as config won't be loaded yet
+      const timeout = this.getConfig('moduleLoadTimeout') ?? 10000
       await Promise.race([
         instance.onReady(),
-        new Promise((resolve, reject) => setTimeout(() => reject(new Error(`${modName} load exceeded timeout (60000)`)), 60000))
+        new Promise((resolve, reject) => setTimeout(() => reject(new Error(`${modName} load exceeded timeout (${timeout})`)), timeout))
       ])
       this.instances[modName] = instance
       await this.moduleLoadedHook.invoke(null, instance)
@@ -169,14 +174,23 @@ class DependencyLoader {
 
   /**
    * Loads a list of Adapt modules. Should not need to be called directly.
-   * @param {Array} modules Module names
-   * @return {Promise} Resolves When all modules have loaded (or failed to load)
+   * @param {Array<string>} modules Module names to load
+   * @param {Object} [options] Loading options
+   * @param {boolean} [options.force=false] If true, logs errors and continues loading other modules when a module fails. If false, throws a DependencyError on first failure.
+   * @return {Promise<void>} Resolves when all modules have loaded (or failed to load in force mode)
+   * @throws {DependencyError} When a module fails to load and options.force is not true
    */
-  async loadModules (modules) {
-    await Promise.allSettled(modules.map(async m => {
+  async loadModules (modules, options = {}) {
+    await Promise.all(modules.map(async m => {
       try {
         await this.loadModule(m)
       } catch (e) {
+        if (options.force !== true) {
+          const error = new Error(`Failed to load '${m}'`)
+          error.name = 'DependencyError'
+          error.cause = e
+          throw error
+        }
         this.logError(`Failed to load '${m}',`, e)
         const deps = this.peerDependencies[m]
         if (deps && deps.length) {
@@ -189,9 +203,10 @@ class DependencyLoader {
   }
 
   /**
-   * Waits for a single module to load
-   * @param {String} modName Name of module to wait for
-   * @return {Promise} Resolves with module instance on module.onReady
+   * Waits for a single module to load. Returns the instance (if loaded), or hooks into moduleLoadedHook to wait for it.
+   * @param {string} modName Name of module to wait for (accepts short names without 'adapt-authoring-' prefix)
+   * @return {Promise<Object>} Resolves with module instance when module.onReady completes
+   * @throws {Error} When module is missing from configs or has failed to load
    */
   async waitForModule (modName) {
     if (!this._configsLoaded) {
@@ -202,8 +217,9 @@ class DependencyLoader {
     if (!this.configs[modName]) {
       throw new Error(`Missing required module '${modName}'`)
     }
+    const DependencyError = new Error(`Dependency '${modName}' failed to load`)
     if (this.failedModules.includes(modName)) {
-      throw new Error(`dependency '${modName}' failed to load`)
+      throw DependencyError
     }
     const instance = this.instances[modName]
     if (instance) {
@@ -211,23 +227,75 @@ class DependencyLoader {
     }
     return new Promise((resolve, reject) => {
       this.moduleLoadedHook.tap((error, instance) => {
-        if (error) return reject(error)
+        if (error) return reject(DependencyError)
         if (instance?.name === modName) resolve(instance)
       })
     })
   }
 
   /**
-   * Logs an error message
-   * @param {...*} args Arguments to be printed
+   * Logs load progress
+   * @param {AbstractModule} instance The last loaded instance
    */
-  logError (...args) {
-    if (this.app.logger && this.app.logger._isReady) {
-      this.app.logger.log('error', this.name, ...args)
+  logProgress (error, instance) {
+    if (error) {
+      return
+    }
+    const toShort = names => names.map(n => n.replace('adapt-authoring-', '')).join(', ')
+    const loaded = []
+    const notLoaded = []
+    let totalCount = 0
+    Object.keys(this.configs).forEach(key => {
+      if (this.configs[key].module === false) return
+      this.instances[key]?._isReady || key === instance.name ? loaded.push(key) : notLoaded.push(key)
+      totalCount++
+    })
+    const progress = Math.round((loaded.length / totalCount) * 100)
+    this.log('verbose', 'LOAD', [
+      toShort([instance.name]),
+      `${loaded.length}/${totalCount} (${progress}%)`,
+      notLoaded.length && `awaiting: ${toShort(notLoaded)}`,
+      this.failedModules.length && `failed: ${toShort(this.failedModules)}`
+    ].filter(Boolean).join(', '))
+
+    if (progress === 100) {
+      const initTimes = Object.entries(this.instances)
+        .sort((a, b) => a[1].initTime < b[1].initTime ? -1 : a[1].initTime > b[1].initTime ? 1 : 0)
+        .reduce((memo, [modName, instance]) => Object.assign(memo, { [modName]: instance.initTime }), {})
+      this.log('verbose', initTimes)
+    }
+  }
+
+  /**
+   * Logs a message using the app logger if available, otherwise falls back to console.log
+   * @param {...*} args Arguments to be logged
+   */
+  log (level, ...args) {
+    if (this.app.logger?._isReady) {
+      this.app.logger.log(level, this.name, ...args)
     } else {
       console.log(...args)
     }
   }
+
+  /**
+   * Logs an error message using the app logger if available, otherwise falls back to console.log
+   * @param {...*} args Arguments to be logged
+   */
+  logError (...args) {
+    this.log('error', ...args)
+  }
+
+  /**
+   * Retrieves a configuration value from this module's config
+   * @param {string} key - The configuration key to retrieve
+   * @returns {*|undefined} The configuration value if config is ready, undefined otherwise
+   */
+  getConfig (key) {
+    if (this.app.config?._isReady) {
+      return this.app.config.get(`adapt-authoring-core.${key}`)
+    }
+  }
 }
 
 export default DependencyLoader

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-core",
-  "version": "1.4.3",
+  "version": "1.6.0",
   "description": "A bundle of reusable 'core' functionality",
   "homepage": "https://github.com/adapt-security/adapt-authoring-core",
   "license": "GPL-3.0",

package/.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"