adapt-authoring-content 1.3.0 → 2.0.0

package/lib/ContentModule.js

@@ -1,5 +1,6 @@
-import { AbstractApiModule, AbstractApiUtils } from 'adapt-authoring-api'
-import { Hook } from 'adapt-authoring-core'
+import { AbstractApiModule } from 'adapt-authoring-api'
+import { getDescendants } from './utils.js'
+import { Hook, stringifyValues } from 'adapt-authoring-core'
 import apidefs from './apidefs.js'
 /**
  * Module which handles course content
@@ -139,7 +140,7 @@ class ContentModule extends AbstractApiModule {
     if (!targetDoc) {
       throw this.app.errors.NOT_FOUND.setData({ type: options.schemaName, id: JSON.stringify(query) })
     }
-    const descendants = await this.getDescendants(targetDoc)
+    const descendants = await getDescendants(q => this.find(q), targetDoc)
 
     await Promise.all([...descendants, targetDoc].map(d => {
       return super.delete({ _id: d._id })
@@ -151,27 +152,6 @@ class ContentModule extends AbstractApiModule {
     return [targetDoc, ...descendants]
   }
 
-  /**
-   * Finds all descendant content items for a given root
-   * @param {Object} rootItem The root item document
-   * @returns {Array<Object>} Array of content items
-   */
-  async getDescendants (rootItem) {
-    const courseItems = await this.find({ _courseId: rootItem._courseId })
-    const descendants = []
-    let items = [rootItem]
-    do {
-      items = items.reduce((m, i) => [...m, ...courseItems.filter(c => c._parentId?.toString() === i._id.toString())], [])
-      descendants.push(...items)
-    } while (items.length)
-
-    if (rootItem._type === 'course') {
-      const config = courseItems.find(c => c._type === 'config')
-      if (config) descendants.push(config)
-    }
-    return descendants
-  }
-
   /**
    * Creates a new parent content type, along with any necessary children
    * @param {external:ExpressRequest} req
@@ -248,7 +228,7 @@ class ContentModule extends AbstractApiModule {
       throw this.app.errors.INVALID_PARENT.setData({ parentId: _parentId })
     }
     const schemaName = originalDoc._type === 'menu' || originalDoc._type === 'page' ? 'contentobject' : originalDoc._type
-    const payload = AbstractApiUtils.stringifyValues({
+    const payload = stringifyValues({
       ...originalDoc,
       _id: undefined,
       _trackingId: undefined,
@@ -261,13 +241,12 @@ class ContentModule extends AbstractApiModule {
 
     if (originalDoc._type === 'course') {
       const [config] = await this.find({ _type: 'config', _courseId: originalDoc._courseId })
-      await this.clone(userId, config._id, undefined, { _courseId: newData._id.toString() })
-      delete payload._id
-      delete payload._courseId
-      // the config did not exist when the new course object was created
-      // schema validation will have therefore stripped the plugin configuration data
-      // here we restore the configuraton data
-      await this.update({ _id: newData._id }, payload)
+      if (config) {
+        await this.clone(userId, config._id, undefined, { _courseId: newData._id.toString() })
+        delete payload._id
+        delete payload._courseId
+        await this.update({ _id: newData._id }, payload)
+      }
     }
     const children = await this.find({ _parentId: _id })
     for (let i = 0; i < children.length; i++) {

package/lib/utils/getDescendants.js

@@ -0,0 +1,22 @@
+/**
+ * Finds all descendant content items for a given root using BFS traversal
+ * @param {Function} findFn Function to query content items (receives query object, returns array)
+ * @param {Object} rootItem The root item document
+ * @returns {Promise<Array<Object>>} Array of descendant content items
+ * @memberof content
+ */
+export async function getDescendants (findFn, rootItem) {
+  const courseItems = await findFn({ _courseId: rootItem._courseId })
+  const descendants = []
+  let items = [rootItem]
+  do {
+    items = items.reduce((m, i) => [...m, ...courseItems.filter(c => c._parentId?.toString() === i._id.toString())], [])
+    descendants.push(...items)
+  } while (items.length)
+
+  if (rootItem._type === 'course') {
+    const config = courseItems.find(c => c._type === 'config')
+    if (config) descendants.push(config)
+  }
+  return descendants
+}

package/lib/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-content",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Module for managing Adapt content",
   "homepage": "https://github.com/adapt-security/adapt-authoring-content",
   "license": "GPL-3.0",
@@ -11,8 +11,8 @@
     "test": "node --test 'tests/**/*.spec.js'"
   },
   "dependencies": {
-    "adapt-authoring-api": "^1.3.2",
-    "adapt-authoring-core": "^1.7.0"
+    "adapt-authoring-api": "^2.0.0",
+    "adapt-authoring-core": "^2.0.0"
   },
   "peerDependencies": {
     "adapt-authoring-authored": "^1.1.1",

package/tests/ContentModule.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, mock, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
+import { getDescendants } from '../lib/utils.js'
 
 /**
  * ContentModule extends AbstractApiModule (which extends AbstractModule).
@@ -338,7 +339,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'root',
         _courseId: 'c1',
         _type: 'page'
@@ -356,7 +357,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'root',
         _courseId: 'c1',
         _type: 'page'
@@ -379,7 +380,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'root',
         _courseId: 'c1',
         _type: 'page'
@@ -401,7 +402,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'c1',
         _courseId: 'c1',
         _type: 'course'
@@ -419,7 +420,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'page1',
         _courseId: 'c1',
         _type: 'page'
@@ -445,7 +446,7 @@ describe('ContentModule', () => {
         find: mock.fn(async () => [parent, child])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, parent)
+      const result = await getDescendants(q => inst.find(q), parent)
 
       assert.equal(result.length, 1)
       assert.equal(result[0]._id, 'child1')
@@ -462,7 +463,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'root',
         _courseId: 'x',
         _type: 'page'
@@ -1607,7 +1608,7 @@ describe('ContentModule', () => {
         ])
       })
 
-      const result = await ContentModule.prototype.getDescendants.call(inst, {
+      const result = await getDescendants(q => inst.find(q), {
         _id: 'root',
         _courseId: 'c1',
         _type: 'course'
@@ -1682,17 +1683,10 @@ describe('ContentModule', () => {
   })
 
   // -----------------------------------------------------------------------
-  // TODO: Potential bugs
+  // Bug fixes
   // -----------------------------------------------------------------------
-  describe('potential bugs', () => {
-    it('TODO: clone of course crashes if no config exists for the course', async () => {
-      // BUG: In clone() line 263, when cloning a course:
-      //   const [config] = await this.find({ _type: 'config', _courseId: originalDoc._courseId })
-      //   await this.clone(userId, config._id, ...)
-      // If no config exists for the course, config is undefined, and
-      // config._id throws TypeError: Cannot read properties of undefined
-      //
-      // The code should check whether config exists before trying to clone it.
+  describe('bug fixes', () => {
+    it('should handle clone of course when no config exists', async () => {
       let findCallCount = 0
       const inst = createInstance({
         find: mock.fn(async () => {
@@ -1706,14 +1700,8 @@ describe('ContentModule', () => {
         postCloneHook: createMockHook()
       })
 
-      // This SHOULD work but crashes due to missing null-check on config
-      await assert.rejects(
-        () => ContentModule.prototype.clone.call(inst, 'user1', 'c1', undefined),
-        (err) => {
-          assert.match(err.message, /Cannot read properties of undefined/)
-          return true
-        }
-      )
+      const result = await ContentModule.prototype.clone.call(inst, 'user1', 'c1', undefined)
+      assert.strictEqual(result._id, 'new-c1')
     })
   })
 })

package/tests/utils-getDescendants.spec.js

@@ -0,0 +1,117 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getDescendants } from '../lib/utils/getDescendants.js'
+
+describe('getDescendants()', () => {
+  const makeId = (n) => ({ toString: () => `id${n}` })
+
+  const courseItems = [
+    { _id: makeId(1), _courseId: 'course1', _type: 'course' },
+    { _id: makeId(2), _courseId: 'course1', _parentId: makeId(1), _type: 'page' },
+    { _id: makeId(3), _courseId: 'course1', _parentId: makeId(2), _type: 'article' },
+    { _id: makeId(4), _courseId: 'course1', _parentId: makeId(3), _type: 'block' },
+    { _id: makeId(5), _courseId: 'course1', _parentId: makeId(4), _type: 'component' },
+    { _id: makeId(6), _courseId: 'course1', _type: 'config' }
+  ]
+
+  const findFn = async (query) => {
+    return courseItems.filter(c => {
+      return Object.entries(query).every(([k, v]) => {
+        const itemVal = c[k]
+        if (itemVal && typeof itemVal.toString === 'function' && typeof v === 'string') {
+          return itemVal.toString() === v
+        }
+        return itemVal === v
+      })
+    })
+  }
+
+  it('should return all descendants of the course (including config)', async () => {
+    const root = courseItems[0]
+    const result = await getDescendants(findFn, root)
+    // Should include page, article, block, component, config = 5 items
+    assert.equal(result.length, 5)
+    assert.ok(result.some(r => r._type === 'page'))
+    assert.ok(result.some(r => r._type === 'article'))
+    assert.ok(result.some(r => r._type === 'block'))
+    assert.ok(result.some(r => r._type === 'component'))
+    assert.ok(result.some(r => r._type === 'config'))
+  })
+
+  it('should return descendants of a page', async () => {
+    const root = courseItems[1] // page
+    const result = await getDescendants(findFn, root)
+    // article, block, component = 3
+    assert.equal(result.length, 3)
+    assert.ok(result.some(r => r._type === 'article'))
+    assert.ok(result.some(r => r._type === 'block'))
+    assert.ok(result.some(r => r._type === 'component'))
+  })
+
+  it('should return descendants of an article', async () => {
+    const root = courseItems[2] // article
+    const result = await getDescendants(findFn, root)
+    // block, component = 2
+    assert.equal(result.length, 2)
+    assert.ok(result.some(r => r._type === 'block'))
+    assert.ok(result.some(r => r._type === 'component'))
+  })
+
+  it('should return empty array for a leaf node', async () => {
+    const root = courseItems[4] // component (leaf)
+    const result = await getDescendants(findFn, root)
+    assert.equal(result.length, 0)
+  })
+
+  it('should not include config for non-course roots', async () => {
+    const root = courseItems[1] // page
+    const result = await getDescendants(findFn, root)
+    assert.ok(!result.some(r => r._type === 'config'))
+  })
+
+  it('should include config for course root', async () => {
+    const root = courseItems[0]
+    const result = await getDescendants(findFn, root)
+    assert.ok(result.some(r => r._type === 'config'))
+  })
+
+  it('should handle course with no config', async () => {
+    const itemsNoConfig = courseItems.filter(c => c._type !== 'config')
+    const findNoConfig = async (query) => {
+      return itemsNoConfig.filter(c => {
+        return Object.entries(query).every(([k, v]) => {
+          const itemVal = c[k]
+          if (itemVal && typeof itemVal.toString === 'function' && typeof v === 'string') {
+            return itemVal.toString() === v
+          }
+          return itemVal === v
+        })
+      })
+    }
+    const root = itemsNoConfig[0] // course
+    const result = await getDescendants(findNoConfig, root)
+    // page, article, block, component = 4 (no config)
+    assert.equal(result.length, 4)
+    assert.ok(!result.some(r => r._type === 'config'))
+  })
+
+  it('should handle empty course (no children)', async () => {
+    const emptyItems = [{ _id: makeId(10), _courseId: 'course10', _type: 'course' }]
+    const emptyFind = async () => emptyItems
+    const root = emptyItems[0]
+    const result = await getDescendants(emptyFind, root)
+    assert.equal(result.length, 0)
+  })
+
+  it('should use findFn with correct query', async () => {
+    const queries = []
+    const trackingFind = async (query) => {
+      queries.push(query)
+      return []
+    }
+    const root = { _id: makeId(99), _courseId: 'courseX', _type: 'page' }
+    await getDescendants(trackingFind, root)
+    assert.equal(queries.length, 1)
+    assert.deepEqual(queries[0], { _courseId: 'courseX' })
+  })
+})