adapt-authoring-content 2.1.8 → 3.0.0

package/lib/ContentTree.js

@@ -0,0 +1,128 @@
+/**
+ * Efficient tree abstraction over a flat array of course content items.
+ * Builds O(1) lookup indexes on construction for parent-child, type, and ID queries.
+ * Pure data structure with no DB access — works on both server and client.
+ * @memberof content
+ */
+class ContentTree {
+  /**
+   * @param {Array<Object>} items Flat array of content items (from a single course)
+   */
+  constructor (items) {
+    /** @type {Array<Object>} */
+    this.items = items
+    /** @type {Map<string, Object>} _id -> item */
+    this.byId = new Map()
+    /** @type {Map<string, Array<Object>>} _parentId -> [children] */
+    this.byParent = new Map()
+    /** @type {Map<string, Array<Object>>} _type -> [items] */
+    this.byType = new Map()
+    /** @type {Object|null} */
+    this.course = null
+    /** @type {Object|null} */
+    this.config = null
+
+    for (const item of items) {
+      const id = item._id.toString()
+      this.byId.set(id, item)
+
+      const parentId = item._parentId?.toString()
+      if (parentId) {
+        if (!this.byParent.has(parentId)) this.byParent.set(parentId, [])
+        this.byParent.get(parentId).push(item)
+      }
+
+      const type = item._type
+      if (!this.byType.has(type)) this.byType.set(type, [])
+      this.byType.get(type).push(item)
+
+      if (type === 'course') this.course = item
+      if (type === 'config') this.config = item
+    }
+  }
+
+  /**
+   * O(1) lookup by ID
+   * @param {string|Object} id
+   * @returns {Object|undefined}
+   */
+  getById (id) {
+    return this.byId.get(id.toString())
+  }
+
+  /**
+   * O(1) children lookup
+   * @param {string|Object} parentId
+   * @returns {Array<Object>}
+   */
+  getChildren (parentId) {
+    return this.byParent.get(parentId.toString()) ?? []
+  }
+
+  /**
+   * O(1) type lookup
+   * @param {string} type
+   * @returns {Array<Object>}
+   */
+  getByType (type) {
+    return this.byType.get(type) ?? []
+  }
+
+  /**
+   * BFS traversal to find all descendants. O(n) where n = number of descendants.
+   * @param {string|Object} rootId
+   * @returns {Array<Object>}
+   */
+  getDescendants (rootId) {
+    const descendants = []
+    const queue = [rootId.toString()]
+    let head = 0
+    while (head < queue.length) {
+      const children = this.byParent.get(queue[head++]) ?? []
+      for (const child of children) {
+        descendants.push(child)
+        queue.push(child._id.toString())
+      }
+    }
+    return descendants
+  }
+
+  /**
+   * Walk up the parent chain. O(d) where d = depth.
+   * @param {string|Object} itemId
+   * @returns {Array<Object>}
+   */
+  getAncestors (itemId) {
+    const ancestors = []
+    let current = this.byId.get(itemId.toString())
+    while (current?._parentId) {
+      current = this.byId.get(current._parentId.toString())
+      if (current) ancestors.push(current)
+    }
+    return ancestors
+  }
+
+  /**
+   * O(1) siblings lookup (excludes the item itself)
+   * @param {string|Object} itemId
+   * @returns {Array<Object>}
+   */
+  getSiblings (itemId) {
+    const id = itemId.toString()
+    const item = this.byId.get(id)
+    if (!item?._parentId) return []
+    return this.getChildren(item._parentId).filter(c => c._id.toString() !== id)
+  }
+
+  /**
+   * O(1) — unique component names across the course
+   * @returns {Array<string>}
+   */
+  getComponentNames () {
+    const names = new Set()
+    for (const c of this.getByType('component')) names.add(c._component)
+    return [...names]
+  }
+}
+
+export default ContentTree

package/lib/utils/computeSortOrderOps.js

@@ -0,0 +1,21 @@
+/**
+ * Computes the bulk-write operations needed to recalculate _sortOrder values.
+ * Optionally splices the target item into the siblings list at the correct position.
+ * @param {Array<Object>} siblings Existing siblings sorted by _sortOrder (excluding the item)
+ * @param {Object} [item] The item being inserted/moved — omit when deleting
+ * @return {Array<Object>} Array of MongoDB updateOne operations
+ */
+export default function computeSortOrderOps (siblings, item) {
+  if (item) {
+    const newSO = item._sortOrder != null && item._sortOrder - 1 > -1 ? item._sortOrder - 1 : siblings.length
+    siblings.splice(newSO, 0, item)
+  }
+  const ops = []
+  for (let i = 0; i < siblings.length; i++) {
+    const _sortOrder = i + 1
+    if (siblings[i]._sortOrder !== _sortOrder) {
+      ops.push({ updateOne: { filter: { _id: siblings[i]._id }, update: { $set: { _sortOrder } } } })
+    }
+  }
+  return ops
+}

package/lib/utils/contentTypeToSchemaName.js

@@ -0,0 +1,9 @@
+/**
+ * Maps a content _type to its corresponding schema name.
+ * 'page' and 'menu' both map to 'contentobject'; all other types map to themselves.
+ * @param {String} _type Content type (e.g. 'page', 'menu', 'article', 'block')
+ * @return {String}
+ */
+export default function contentTypeToSchemaName (_type) {
+  return _type === 'page' || _type === 'menu' ? 'contentobject' : _type
+}

package/lib/utils/extractAssetIds.js

@@ -0,0 +1,18 @@
+/**
+ * Extracts unique asset IDs from a content document by walking its schema
+ * for Asset-type fields and collecting non-URL values.
+ * @param {Object} schema The built Schema instance (must have a walk method)
+ * @param {Object} data The data object to search for asset values
+ * @return {Array<String>} Unique array of asset IDs found in the data
+ * @memberof content
+ */
+export function extractAssetIds (schema, data) {
+  const isAssetField = (field) =>
+    field?._backboneForms?.type === 'Asset' || field?._backboneForms === 'Asset'
+
+  return [...new Set(
+    schema.walk(data, isAssetField)
+      .map(match => match.value?.toString())
+      .filter(v => v && !v.startsWith('http://') && !v.startsWith('https://'))
+  )]
+}

package/lib/utils/formatFriendlyId.js

@@ -0,0 +1,12 @@
+/**
+ * Formats a friendly ID string from content type, sequence number and optional language
+ * @param {String} _type Content type (e.g. 'course', 'block', 'component')
+ * @param {Number} count Current sequence number
+ * @param {String} [_language] Language code (only used for courses)
+ * @return {String}
+ */
+export default function formatFriendlyId (_type, count, _language) {
+  if (_type === 'course') return `course-${count}${_language ? `-${_language}` : ''}`
+  if (_type === 'config') return 'config'
+  return `${_type[0]}-${count}`
+}

package/lib/utils/parseMaxSeq.js

@@ -0,0 +1,16 @@
+/**
+ * Parses friendly ID strings from content docs and returns the highest sequence number.
+ * @param {Array<Object>} docs Array of objects with a `_friendlyId` property
+ * @return {Number}
+ */
+export default function parseMaxSeq (docs) {
+  let maxNum = 0
+  for (const doc of docs) {
+    const match = doc._friendlyId?.match(/(\d+)/)
+    if (match) {
+      const num = parseInt(match[1])
+      if (num > maxNum) maxNum = num
+    }
+  }
+  return maxNum
+}

package/lib/utils.js

@@ -1 +1,6 @@
-export { getDescendants } from './utils/getDescendants.js'
+export { default as ContentTree } from './ContentTree.js'
+export { default as computeSortOrderOps } from './utils/computeSortOrderOps.js'
+export { extractAssetIds } from './utils/extractAssetIds.js'
+export { default as contentTypeToSchemaName } from './utils/contentTypeToSchemaName.js'
+export { default as formatFriendlyId } from './utils/formatFriendlyId.js'
+export { default as parseMaxSeq } from './utils/parseMaxSeq.js'

package/migrations/3.0.0.js

@@ -0,0 +1,123 @@
+import { ObjectId } from 'mongodb'
+import formatFriendlyId from '../lib/utils/formatFriendlyId.js'
+import parseMaxSeq from '../lib/utils/parseMaxSeq.js'
+
+export default function (migration) {
+  migration.describe('Backfill _friendlyId and _assetIds on existing content documents')
+  migration.runCommand(backfillFriendlyIds)
+  migration.runCommand(backfillAssetIds)
+}
+
+async function backfillFriendlyIds (db, log) {
+  const content = db.collection('content')
+
+  const missing = await content.find({
+    $or: [
+      { _friendlyId: { $exists: false } },
+      { _friendlyId: '' }
+    ]
+  }).toArray()
+
+  if (missing.length === 0) {
+    log('info', 'migrations', 'No content documents missing _friendlyId, skipping')
+    return
+  }
+  log('info', 'migrations', `Backfilling _friendlyId for ${missing.length} document(s)`)
+
+  // Group by _courseId + _type to allocate sequential IDs per group
+  const groups = new Map()
+  for (const doc of missing) {
+    const courseId = doc._courseId?.toString() ?? 'none'
+    const type = doc._type
+    const key = `${courseId}:${type}`
+    if (!groups.has(key)) groups.set(key, { courseId, type, docs: [] })
+    groups.get(key).docs.push(doc)
+  }
+
+  for (const { courseId, type, docs } of groups.values()) {
+    if (type === 'config') {
+      for (const doc of docs) {
+        await content.updateOne({ _id: doc._id }, { $set: { _friendlyId: formatFriendlyId('config') } })
+      }
+      continue
+    }
+
+    const isCourse = type === 'course'
+    const query = {
+      _type: type,
+      _friendlyId: { $exists: true, $ne: '' }
+    }
+    if (!isCourse && courseId !== 'none') {
+      query._courseId = docs[0]._courseId
+    }
+
+    const existing = await content.find(query, { projection: { _friendlyId: 1 } }).toArray()
+    const maxSeq = parseMaxSeq(existing)
+
+    let nextSeq = maxSeq + 1
+    for (const doc of docs) {
+      const friendlyId = formatFriendlyId(type, nextSeq, doc._language)
+      await content.updateOne({ _id: doc._id }, { $set: { _friendlyId: friendlyId } })
+      nextSeq++
+    }
+  }
+  log('info', 'migrations', `Backfilled _friendlyId for ${missing.length} document(s)`)
+}
+
+async function backfillAssetIds (db, log) {
+  const content = db.collection('content')
+  const assets = db.collection('assets')
+
+  const docsToUpdate = await content.find({
+    $or: [
+      { _assetIds: { $exists: false } },
+      { _assetIds: null }
+    ]
+  }).toArray()
+
+  if (docsToUpdate.length === 0) {
+    log('info', 'migrations', 'No content documents missing _assetIds, skipping')
+    return
+  }
+
+  // Build a set of all asset ID strings for fast lookup
+  const assetIds = await assets.distinct('_id')
+  const assetIdStrings = assetIds.map(id => id.toString())
+
+  if (assetIdStrings.length === 0) {
+    // No assets in the DB — set all to empty array
+    await content.updateMany(
+      { $or: [{ _assetIds: { $exists: false } }, { _assetIds: null }] },
+      { $set: { _assetIds: [] } }
+    )
+    log('info', 'migrations', `Set _assetIds to [] for ${docsToUpdate.length} document(s) (no assets in DB)`)
+    return
+  }
+
+  log('info', 'migrations', `Backfilling _assetIds for ${docsToUpdate.length} document(s) against ${assetIdStrings.length} known asset(s)`)
+
+  let updated = 0
+  const ops = []
+  for (const doc of docsToUpdate) {
+    const docStr = JSON.stringify(doc)
+    const foundIds = assetIdStrings
+      .filter(id => docStr.includes(id))
+      .map(id => new ObjectId(id))
+    ops.push({
+      updateOne: {
+        filter: { _id: doc._id },
+        update: { $set: { _assetIds: foundIds } }
+      }
+    })
+    if (ops.length >= 500) {
+      await content.bulkWrite(ops, { ordered: false })
+      updated += ops.length
+      ops.length = 0
+    }
+  }
+  if (ops.length > 0) {
+    await content.bulkWrite(ops, { ordered: false })
+    updated += ops.length
+  }
+  log('info', 'migrations', `Backfilled _assetIds for ${updated} document(s)`)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-content",
-  "version": "2.1.8",
+  "version": "3.0.0",
   "description": "Module for managing Adapt content",
   "homepage": "https://github.com/adapt-security/adapt-authoring-content",
   "license": "GPL-3.0",
@@ -12,13 +12,14 @@
   },
   "dependencies": {
     "adapt-authoring-api": "^3.0.0",
-    "adapt-authoring-core": "^2.0.0"
+    "adapt-authoring-core": "^2.0.0",
+    "adapt-authoring-mongodb": "^3.1.0"
   },
   "peerDependencies": {
+    "adapt-authoring-assets": "^1.0.0",
     "adapt-authoring-authored": "^1.1.1",
     "adapt-authoring-contentplugin": "^1.0.6",
     "adapt-authoring-jsonschema": "^1.2.0",
-    "adapt-authoring-mongodb": "^3.0.0",
     "adapt-authoring-tags": "^1.0.2"
   },
   "devDependencies": {

package/routes.json

@@ -1,6 +1,57 @@
 {
   "root": "content",
   "routes": [
+    {
+      "route": "/tree/:_courseId",
+      "handlers": { "get": "handleTree" },
+      "permissions": { "get": ["read:${scope}"] },
+      "meta": {
+        "get": {
+          "summary": "Get lightweight content tree for a course",
+          "description": "Returns a projected subset of fields for all content items in a course, suitable for rendering tree views without fetching full documents. Supports If-Modified-Since for conditional requests — returns 304 if the course has not been modified since the given date.",
+          "parameters": [
+            { "name": "_courseId", "in": "path", "description": "The course _id", "required": true },
+            { "name": "If-Modified-Since", "in": "header", "description": "Return 304 if the course has not been modified since this date", "required": false }
+          ],
+          "responses": {
+            "200": {
+              "description": "Array of projected content items",
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "$schema": "https://json-schema.org/draft/2020-12/schema",
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "_id": { "type": "string" },
+                        "_parentId": { "type": "string" },
+                        "_courseId": { "type": "string" },
+                        "_type": { "type": "string" },
+                        "_sortOrder": { "type": "number" },
+                        "title": { "type": "string" },
+                        "displayTitle": { "type": "string" },
+                        "_friendlyId": { "type": "string" },
+                        "_component": { "type": "string" },
+                        "_layout": { "type": "string" },
+                        "_menu": { "type": "string" },
+                        "_theme": { "type": "string" },
+                        "_enabledPlugins": { "type": "array", "items": { "type": "string" } },
+                        "updatedAt": { "type": "string", "format": "date-time" },
+                        "_children": { "type": "array", "items": { "type": "string" } }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "304": {
+              "description": "Course has not been modified since the If-Modified-Since date"
+            }
+          }
+        }
+      }
+    },
     {
       "route": "/insertrecursive",
       "handlers": { "post": "handleInsertRecursive" },

package/schema/contentassets.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$anchor": "contentassets",
+  "description": "Tracks asset IDs referenced by content items",
+  "$merge": {
+    "with": {
+      "properties": {
+        "_assetIds": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": [],
+          "_adapt": { "editorOnly": true },
+          "_backboneForms": { "showInUi": false }
+        }
+      }
+    }
+  }
+}