adapt-authoring-adaptframework 2.2.0 → 2.3.1

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/AdaptFrameworkImport.js

@@ -804,7 +804,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 +833,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}
@@ -252,6 +264,9 @@ class AdaptFrameworkModule extends AbstractModule {
     const builder = new AdaptFrameworkBuild(options)
     builder.preBuildHook.tap(() => this.preBuildHook.invoke(builder))
     builder.postBuildHook.tap(() => this.postBuildHook.invoke(builder))
+    if (this.buildHook.hasObservers) {
+      return this.buildHook.invoke(async () => builder.build(), builder)
+    }
     return builder.build()
   }
 
@@ -264,6 +279,9 @@ class AdaptFrameworkModule extends AbstractModule {
     const importer = new AdaptFrameworkImport(options)
     importer.preImportHook.tap(() => this.preImportHook.invoke(importer))
     importer.postImportHook.tap(() => this.postImportHook.invoke(importer))
+    if (this.importHook.hasObservers) {
+      return this.importHook.invoke(async () => importer.import(), importer)
+    }
     return importer.import()
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "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')
     })
   })