adapt-authoring-courseassets 1.0.5 → 1.2.0

package/.github/workflows/tests.yml

@@ -0,0 +1,15 @@
+name: Tests
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/lib/courseassetsModule.js

@@ -1,4 +1,5 @@
 import AbstractApiModule from 'adapt-authoring-api'
+import { extractAssetIds } from './utils.js'
 /**
  * Module which handles courseassets automatically using on content events
  * @memberof courseassets
@@ -46,29 +47,6 @@ class CourseAssetsModule extends AbstractApiModule {
     })
   }
 
-  /**
-   * Search data object for asset types and retrieve _ids
-   * @param {Object} data
-   */
-  extractAssetIds (schema, data, assets = []) {
-    Object.entries(schema).forEach(([key, val]) => {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
-        return
-      }
-      if (val.properties) {
-        this.extractAssetIds(val.properties, data[key], assets)
-      } else if (val?.items?.properties) {
-        data[key].forEach(d => this.extractAssetIds(val.items.properties, d, assets))
-      } else if ((val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') && data[key]) {
-        const v = data[key].toString()
-        if (!v.startsWith('http://') && !v.startsWith('https://')) {
-          assets.push(v)
-        }
-      }
-    })
-    return Array.from(new Set(assets))
-  };
-
   /**
    * Handler for content event
    * @param {String} action The action performed
@@ -96,7 +74,7 @@ class CourseAssetsModule extends AbstractApiModule {
 
     const data = isModify ? arg2 : arg1
     const schema = await this.content.getSchema(this.content.schemaName, data)
-    const ids = this.extractAssetIds(schema.built.properties, data)
+    const ids = extractAssetIds(schema.built.properties, data)
 
     if (!ids.length) {
       return

package/lib/utils/extractAssetIds.js

@@ -0,0 +1,26 @@
+/**
+ * Searches a data object for asset-type schema properties and collects their IDs
+ * @param {Object} schema The schema properties to traverse
+ * @param {Object} data The data object to search for asset values
+ * @param {Array<String>} assets Accumulator array for found asset IDs
+ * @return {Array<String>} Unique array of asset IDs found in the data
+ * @memberof courseassets
+ */
+export function extractAssetIds (schema, data, assets = []) {
+  Object.entries(schema).forEach(([key, val]) => {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      return
+    }
+    if (val.properties) {
+      extractAssetIds(val.properties, data[key], assets)
+    } else if (val?.items?.properties) {
+      data[key].forEach(d => extractAssetIds(val.items.properties, d, assets))
+    } else if ((val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') && data[key]) {
+      const v = data[key].toString()
+      if (!v.startsWith('http://') && !v.startsWith('https://')) {
+        assets.push(v)
+      }
+    }
+  })
+  return Array.from(new Set(assets))
+}

package/lib/utils.js

@@ -0,0 +1 @@
+export { extractAssetIds } from './utils/extractAssetIds.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-courseassets",
-  "version": "1.0.5",
+  "version": "1.2.0",
   "description": "Module for managing courseassets",
   "homepage": "https://github.com/deltanetdan/adapt-authoring-courseassets",
   "license": "GPL-3.0",
@@ -10,7 +10,7 @@
   "peerDependencies": {
     "adapt-authoring-assets": "^1.3.1",
     "adapt-authoring-content": "^1.2.3",
-    "adapt-authoring-core": "^1.7.0"
+    "adapt-authoring-core": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "adapt-authoring-assets": {
@@ -55,5 +55,8 @@
         }
       ]
     ]
+  },
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
   }
 }

package/tests/CourseAssetsModule.spec.js

@@ -0,0 +1,138 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+/**
+ * CourseAssetsModule extends AbstractApiModule which requires a running app.
+ * We test the extractAssetIds method logic in isolation.
+ */
+
+/* ---------- inline helper: extract extractAssetIds logic ---------- */
+function extractAssetIds (schema, data, assets = []) {
+  Object.entries(schema).forEach(([key, val]) => {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      return
+    }
+    if (val.properties) {
+      extractAssetIds(val.properties, data[key], assets)
+    } else if (val?.items?.properties) {
+      data[key].forEach(d => extractAssetIds(val.items.properties, d, assets))
+    } else if ((val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') && data[key]) {
+      const v = data[key].toString()
+      if (!v.startsWith('http://') && !v.startsWith('https://')) {
+        assets.push(v)
+      }
+    }
+  })
+  return Array.from(new Set(assets))
+}
+
+describe('CourseAssetsModule', () => {
+  describe('#extractAssetIds()', () => {
+    it('should extract asset IDs from flat schema', () => {
+      const schema = {
+        heroImage: { _backboneForms: { type: 'Asset' } }
+      }
+      const data = { heroImage: 'asset123' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['asset123'])
+    })
+
+    it('should extract asset IDs using short _backboneForms notation', () => {
+      const schema = {
+        graphic: { _backboneForms: 'Asset' }
+      }
+      const data = { graphic: 'asset456' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['asset456'])
+    })
+
+    it('should skip HTTP URLs', () => {
+      const schema = {
+        image: { _backboneForms: 'Asset' }
+      }
+      const data = { image: 'http://example.com/img.png' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, [])
+    })
+
+    it('should skip HTTPS URLs', () => {
+      const schema = {
+        image: { _backboneForms: 'Asset' }
+      }
+      const data = { image: 'https://example.com/img.png' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, [])
+    })
+
+    it('should recurse into nested properties', () => {
+      const schema = {
+        _globals: {
+          properties: {
+            logo: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+      const data = { _globals: { logo: 'logo123' } }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['logo123'])
+    })
+
+    it('should recurse into array items', () => {
+      const schema = {
+        _items: {
+          items: {
+            properties: {
+              src: { _backboneForms: { type: 'Asset' } }
+            }
+          }
+        }
+      }
+      const data = {
+        _items: [
+          { src: 'item1' },
+          { src: 'item2' }
+        ]
+      }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['item1', 'item2'])
+    })
+
+    it('should deduplicate asset IDs', () => {
+      const schema = {
+        img1: { _backboneForms: 'Asset' },
+        img2: { _backboneForms: 'Asset' }
+      }
+      const data = { img1: 'same', img2: 'same' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['same'])
+    })
+
+    it('should skip keys not present in data', () => {
+      const schema = {
+        present: { _backboneForms: 'Asset' },
+        missing: { _backboneForms: 'Asset' }
+      }
+      const data = { present: 'val1' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, ['val1'])
+    })
+
+    it('should skip falsy data values', () => {
+      const schema = {
+        image: { _backboneForms: 'Asset' }
+      }
+      const data = { image: '' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, [])
+    })
+
+    it('should return empty array when no assets found', () => {
+      const schema = {
+        title: { type: 'string' }
+      }
+      const data = { title: 'hello' }
+      const result = extractAssetIds(schema, data)
+      assert.deepEqual(result, [])
+    })
+  })
+})

package/tests/utils-extractAssetIds.spec.js

@@ -0,0 +1,112 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { extractAssetIds } from '../lib/utils/extractAssetIds.js'
+
+describe('extractAssetIds()', () => {
+  it('should return empty array when no asset fields exist', () => {
+    const schema = { title: { type: 'string' } }
+    const data = { title: 'test' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should extract asset ID from _backboneForms Asset string type', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'abc123' }
+    assert.deepEqual(extractAssetIds(schema, data), ['abc123'])
+  })
+
+  it('should extract asset ID from _backboneForms.type Asset', () => {
+    const schema = { image: { _backboneForms: { type: 'Asset' } } }
+    const data = { image: 'abc123' }
+    assert.deepEqual(extractAssetIds(schema, data), ['abc123'])
+  })
+
+  it('should skip keys not present in data', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = {}
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip falsy asset values', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: '' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip HTTP URLs', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'http://example.com/image.png' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip HTTPS URLs', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'https://example.com/image.png' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should recurse into nested schema properties', () => {
+    const schema = {
+      _graphic: {
+        properties: {
+          src: { _backboneForms: 'Asset' }
+        }
+      }
+    }
+    const data = { _graphic: { src: 'img123' } }
+    assert.deepEqual(extractAssetIds(schema, data), ['img123'])
+  })
+
+  it('should recurse into array items with properties', () => {
+    const schema = {
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    }
+    const data = { _items: [{ src: 'a1' }, { src: 'a2' }] }
+    assert.deepEqual(extractAssetIds(schema, data), ['a1', 'a2'])
+  })
+
+  it('should deduplicate asset IDs', () => {
+    const schema = {
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    }
+    const data = { _items: [{ src: 'same' }, { src: 'same' }] }
+    assert.deepEqual(extractAssetIds(schema, data), ['same'])
+  })
+
+  it('should accumulate with provided assets array', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'new1' }
+    const existing = ['existing1']
+    const result = extractAssetIds(schema, data, existing)
+    assert.ok(result.includes('existing1'))
+    assert.ok(result.includes('new1'))
+  })
+
+  it('should handle toString on non-string asset values', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: { toString: () => 'obj123' } }
+    assert.deepEqual(extractAssetIds(schema, data), ['obj123'])
+  })
+
+  it('should handle multiple asset fields at the same level', () => {
+    const schema = {
+      image1: { _backboneForms: 'Asset' },
+      image2: { _backboneForms: { type: 'Asset' } },
+      title: { type: 'string' }
+    }
+    const data = { image1: 'a1', image2: 'a2', title: 'test' }
+    assert.deepEqual(extractAssetIds(schema, data), ['a1', 'a2'])
+  })
+})