adapt-authoring-adaptframework 2.2.0 → 2.3.0

package/.github/workflows/standardjs.yml

@@ -1,4 +1,4 @@
-name: Standard.js formatting check
+name: Lint
 on: push
 jobs:
   default:
@@ -9,4 +9,4 @@ jobs:
         with:
           node-version: 'lts/*'
       - run: npm install
-      - run: npx standard
+      - run: npx standard

package/lib/AdaptFrameworkBuild.js

@@ -1,5 +1,5 @@
 import _ from 'lodash'
-import { App, Hook, ensureDir, writeJson } from 'adapt-authoring-core'
+import { App, ensureDir, writeJson } from 'adapt-authoring-core'
 import { parseObjectId } from 'adapt-authoring-mongodb'
 import { createWriteStream } from 'node:fs'
 import AdaptCli from 'adapt-cli'
@@ -140,16 +140,6 @@ class AdaptFrameworkBuild {
      * @type {Array<Object>}
      */
     this.disabledPlugins = []
-    /**
-     * Invoked prior to a course being built.
-     * @type {Hook}
-     */
-    this.preBuildHook = new Hook({ mutable: true })
-    /**
-      * Invoked after a course has been built.
-      * @type {Hook}
-      */
-    this.postBuildHook = new Hook({ mutable: true })
   }
 
   /**
@@ -190,8 +180,6 @@ class AdaptFrameworkBuild {
         linkNodeModules: !this.isExport
       })
     ])
-    await this.preBuildHook.invoke(this)
-
     await this.writeContentJson()
 
     logDir('courseDir', this.courseDir)
@@ -218,8 +206,6 @@ class AdaptFrameworkBuild {
     } else {
       this.location = this.isPreview ? path.join(this.dir, 'build') : this.dir
     }
-    await this.postBuildHook.invoke(this)
-
     this.buildData = await this.recordBuildAttempt()
 
     return this

package/lib/AdaptFrameworkImport.js

@@ -1,4 +1,4 @@
-import { App, Hook, spawn, readJson, writeJson } from 'adapt-authoring-core'
+import { App, spawn, readJson, writeJson } from 'adapt-authoring-core'
 import { parseObjectId } from 'adapt-authoring-mongodb'
 import fs from 'node:fs/promises'
 import { glob } from 'glob'
@@ -194,15 +194,6 @@ class AdaptFrameworkImport {
       updatePlugins,
       removeSource
     }
-    /**
-     * Invoked before the import process has started
-     */
-    this.preImportHook = new Hook()
-    /**
-     * Invoked once the import process has completed
-     */
-    this.postImportHook = new Hook()
-
     /**
      * plugins on import that are of a lower version than the installed version
      * @type {Array}
@@ -264,7 +255,6 @@ class AdaptFrameworkImport {
         [this.prepare],
         [this.loadAssetData],
         [this.loadPluginData],
-        [() => this.preImportHook.invoke(this)],
         [this.importTags, importContent],
         [this.importCourseAssets, importContent],
         [this.importCoursePlugins, isDryRun && importPlugins],
@@ -278,7 +268,6 @@ class AdaptFrameworkImport {
       for (const task of tasks) {
         if (task.length < 2 || task[1]) await task[0].call(this)
       }
-      await this.postImportHook.invoke(this)
     } catch (e) {
       error = e
     }
@@ -804,7 +793,7 @@ class AdaptFrameworkImport {
     const schemaName = AdaptFrameworkImport.typeToSchema(data)
     const schema = await this.content.getSchema(schemaName, insertData)
     try {
-      this.extractAssets(schema.built.properties, insertData)
+      this.resolveAssets(schema, insertData)
     } catch (e) {
       log('error', `failed to extract asset data for attribute '${e.attribute}' of schema '${schemaName}', ${e}`)
     }
@@ -833,27 +822,16 @@ class AdaptFrameworkImport {
   }
 
   /**
-   * Infers the presence of any assets in incoming JSON data
-   * @param {Object} schema Schema for the passed data
+   * Replaces asset paths in incoming JSON data with the _id for the corresponding asset, as used internally
+   * @param {Object} schema Schema instance for the passed data
    * @param {Object} data Data to check
    */
-  extractAssets (schema, data) {
-    if (!schema) {
-      return
-    }
-    Object.entries(schema).forEach(([key, val]) => {
-      if (data[key] === undefined) {
-        return
-      }
-      if (val.properties) {
-        this.extractAssets(val.properties, data[key])
-      } else if (val?.items?.properties) {
-        data[key].forEach(d => this.extractAssets(val.items.properties, d))
-      } else if (val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') {
-        data[key] !== ''
-          ? data[key] = this.assetMap[data[key]] ?? data[key]
-          : delete data[key]
-      }
+  resolveAssets (schema, data) {
+    if (!schema) return
+    schema.walk(data, field =>
+      field?._backboneForms?.type === 'Asset' || field?._backboneForms === 'Asset'
+    ).forEach(({ data: parent, key, value }) => {
+      value ? parent[key] = this.assetMap[value] ?? value : delete parent[key]
     })
   }
 

package/lib/AdaptFrameworkModule.js

@@ -52,6 +52,18 @@ class AdaptFrameworkModule extends AbstractModule {
      * @type {Hook}
      */
     this.postBuildHook = new Hook({ mutable: true })
+    /**
+     * Middleware hook wrapping the full import lifecycle (pre → import → post).
+     * Observers receive (next, importer) and must call next() to proceed.
+     * @type {Hook}
+     */
+    this.importHook = new Hook({ type: Hook.Types.Middleware })
+    /**
+     * Middleware hook wrapping the full build lifecycle (pre → build → post).
+     * Observers receive (next, builder) and must call next() to proceed.
+     * @type {Hook}
+     */
+    this.buildHook = new Hook({ type: Hook.Types.Middleware })
     /**
      * Content migration functions to be run on import
      * @type {Array}
@@ -250,9 +262,16 @@ class AdaptFrameworkModule extends AbstractModule {
    */
   async buildCourse (options) {
     const builder = new AdaptFrameworkBuild(options)
-    builder.preBuildHook.tap(() => this.preBuildHook.invoke(builder))
-    builder.postBuildHook.tap(() => this.postBuildHook.invoke(builder))
-    return builder.build()
+    const core = async () => {
+      await this.preBuildHook.invoke(builder)
+      await builder.build()
+      await this.postBuildHook.invoke(builder)
+      return builder
+    }
+    if (this.buildHook.hasObservers) {
+      return this.buildHook.invoke(core, builder)
+    }
+    return core()
   }
 
   /**
@@ -262,9 +281,16 @@ class AdaptFrameworkModule extends AbstractModule {
    */
   async importCourse (options) {
     const importer = new AdaptFrameworkImport(options)
-    importer.preImportHook.tap(() => this.preImportHook.invoke(importer))
-    importer.postImportHook.tap(() => this.postImportHook.invoke(importer))
-    return importer.import()
+    const core = async () => {
+      await this.preImportHook.invoke(importer)
+      await importer.import()
+      await this.postImportHook.invoke(importer)
+      return importer
+    }
+    if (this.importHook.hasObservers) {
+      return this.importHook.invoke(core, importer)
+    }
+    return core()
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Adapt framework integration for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-adaptframework",
   "license": "GPL-3.0",
@@ -32,7 +32,7 @@
   "peerDependencies": {
     "adapt-authoring-assets": "^1.4.3",
     "adapt-authoring-auth": "^2.0.0",
-    "adapt-authoring-jsonschema": "^1.1.5",
+    "adapt-authoring-jsonschema": "^1.4.0",
     "adapt-authoring-middleware": "^1.0.1",
     "adapt-authoring-server": "^2.1.0",
     "adapt-authoring-tags": "^1.0.1"

package/tests/AdaptFrameworkImport.spec.js

@@ -148,54 +148,78 @@ describe('AdaptFrameworkImport', () => {
     })
   })
 
-  describe('#extractAssets()', () => {
+  describe('#resolveAssets()', () => {
     function makeCtx (assetMap) {
       const ctx = { assetMap }
-      ctx.extractAssets = AdaptFrameworkImport.prototype.extractAssets.bind(ctx)
+      ctx.resolveAssets = AdaptFrameworkImport.prototype.resolveAssets.bind(ctx)
       return ctx
     }
 
+    function makeSchema (properties) {
+      return {
+        built: { properties },
+        walk (data, predicate, props, parentPath = '') {
+          props = props ?? this.built.properties
+          const matches = []
+          for (const [key, val] of Object.entries(props)) {
+            if (data[key] === undefined) continue
+            const currentPath = parentPath ? `${parentPath}/${key}` : key
+            if (val.properties) {
+              matches.push(...this.walk(data[key], predicate, val.properties, currentPath))
+            } else if (val?.items?.properties) {
+              data[key].forEach((item, i) => {
+                matches.push(...this.walk(item, predicate, val.items.properties, `${currentPath}/${i}`))
+              })
+            } else if (predicate(val)) {
+              matches.push({ path: currentPath, key, data, value: data[key] })
+            }
+          }
+          return matches
+        }
+      }
+    }
+
     it('should replace asset paths with mapped IDs', () => {
       const ctx = makeCtx({ 'course/en/assets/logo.png': 'asset123' })
-      const schema = {
+      const schema = makeSchema({
         _graphic: {
           properties: {
             src: { _backboneForms: 'Asset' }
           }
         }
-      }
+      })
       const data = { _graphic: { src: 'course/en/assets/logo.png' } }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal(data._graphic.src, 'asset123')
     })
 
     it('should delete empty string asset values', () => {
       const ctx = makeCtx({})
-      const schema = {
+      const schema = makeSchema({
         _graphic: {
           properties: {
             src: { _backboneForms: 'Asset' }
           }
         }
-      }
+      })
       const data = { _graphic: { src: '' } }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal('src' in data._graphic, false)
     })
 
     it('should keep value when not in assetMap', () => {
       const ctx = makeCtx({})
-      const schema = {
+      const schema = makeSchema({
         img: { _backboneForms: { type: 'Asset' } }
-      }
+      })
       const data = { img: 'unknown/path.png' }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal(data.img, 'unknown/path.png')
     })
 
     it('should recurse into nested properties', () => {
       const ctx = makeCtx({ 'assets/bg.jpg': 'asset456' })
-      const schema = {
+      const schema = makeSchema({
         _settings: {
           properties: {
             _background: {
@@ -205,15 +229,15 @@ describe('AdaptFrameworkImport', () => {
             }
           }
         }
-      }
+      })
       const data = { _settings: { _background: { src: 'assets/bg.jpg' } } }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal(data._settings._background.src, 'asset456')
     })
 
     it('should recurse into array items', () => {
       const ctx = makeCtx({ 'assets/a.png': 'id1', 'assets/b.png': 'id2' })
-      const schema = {
+      const schema = makeSchema({
         _items: {
           items: {
             properties: {
@@ -221,40 +245,40 @@ describe('AdaptFrameworkImport', () => {
             }
           }
         }
-      }
+      })
       const data = {
         _items: [
           { src: 'assets/a.png' },
           { src: 'assets/b.png' }
         ]
       }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal(data._items[0].src, 'id1')
       assert.equal(data._items[1].src, 'id2')
     })
 
     it('should skip undefined data keys', () => {
       const ctx = makeCtx({})
-      const schema = {
+      const schema = makeSchema({
         _graphic: { _backboneForms: 'Asset' }
-      }
+      })
       const data = {}
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal('_graphic' in data, false)
     })
 
     it('should handle null schema gracefully', () => {
       const ctx = makeCtx({})
-      ctx.extractAssets(null, { a: 1 })
+      ctx.resolveAssets(null, { a: 1 })
     })
 
     it('should handle _backboneForms as object with type', () => {
       const ctx = makeCtx({ 'path/img.png': 'mapped' })
-      const schema = {
+      const schema = makeSchema({
         hero: { _backboneForms: { type: 'Asset' } }
-      }
+      })
       const data = { hero: 'path/img.png' }
-      ctx.extractAssets(schema, data)
+      ctx.resolveAssets(schema, data)
       assert.equal(data.hero, 'mapped')
     })
   })