adapt-authoring-content 3.2.4 → 3.4.0

package/lib/ContentModule.js

@@ -2,7 +2,7 @@ import { AbstractApiModule } from 'adapt-authoring-api'
 import { Hook, stringifyValues } from 'adapt-authoring-core'
 import { createObjectId, parseObjectId } from 'adapt-authoring-mongodb'
 import { ObjectId } from 'mongodb'
-import { ContentTree, buildAssetUsagePipeline, computeSortOrderOps, contentTypeToSchemaName, extractAssetIds, fieldsToProjection, formatFriendlyId, parseMaxSeq, treeEtag } from './utils.js'
+import { ContentTree, buildAssetUsagePipeline, computeSortOrderOps, contentTypeToSchemaName, excludeIdsFromQuery, extractAssetIds, fieldsToProjection, formatFriendlyId, parseMaxSeq, treeEtag } from './utils.js'
 /**
  * Module which handles course content
  * @memberof content
@@ -58,6 +58,7 @@ class ContentModule extends AbstractApiModule {
     this.postDeleteHook.tap(this.touchCourse.bind(this))
 
     assets.preDeleteHook.tap(this.enforceAssetNotInUse.bind(this))
+    assets.queryHook.tap(this.onAssetQueryHook, this)
 
     // block builds when the course structure has empty containers. adaptframework depends on
     // content (not vice-versa), so tap its hook once available rather than awaiting it here.
@@ -149,6 +150,27 @@ class ContentModule extends AbstractApiModule {
     }
   }
 
+  /**
+   * "Unused assets" filter for the asset manager. The UI sends a `?unused`
+   * query-string flag (see adapt-authoring-ui Assets page); restrict the assets
+   * query to those not referenced by any content document. Read from req.query
+   * because the flag is not part of the asset schema.
+   *
+   * Lives here, tapping the assets module's queryHook, so the `_assetIds`
+   * mechanism stays owned by content and assets remains usage-agnostic. Uses
+   * queryHook (not accessQueryHook) because it's a user-driven filter that must
+   * apply to every role.
+   * @param {external:ExpressRequest} req
+   * @return {Promise}
+   */
+  async onAssetQueryHook (req) {
+    if (!req.query.unused) return
+    // distinct can surface a null when legacy docs carry a null in _assetIds;
+    // those would crash the mongodb layer's ObjectId conversion of the $nin array
+    const usedIds = (await this.mongodb.getCollection(this.collectionName).distinct('_assetIds')).filter(Boolean)
+    excludeIdsFromQuery(req.apiData.query, usedIds)
+  }
+
   /** @override */
   async getSchemaName (data) {
     const { contentplugin } = this
@@ -694,6 +716,7 @@ class ContentModule extends AbstractApiModule {
         '_theme',
         '_enabledPlugins',
         '_colorLabel',
+        '_language',
         'heroImage',
         'updatedAt'
       ]

package/lib/utils/excludeIdsFromQuery.js

@@ -0,0 +1,22 @@
+/**
+ * Mutates a mongo query to exclude the given `_id`s. If the query already
+ * has an `_id` constraint, both are preserved via `$and` so existing filters
+ * are not silently dropped.
+ * @param {Object} query The mongo query object to mutate
+ * @param {Array} ids Document `_id`s to exclude. Falsy or empty → no-op
+ * @memberof content
+ */
+export function excludeIdsFromQuery (query, ids) {
+  if (!ids?.length) return
+  const existing = query._id
+  if (existing) {
+    query.$and = [
+      ...(query.$and ?? []),
+      { _id: existing },
+      { _id: { $nin: ids } }
+    ]
+    delete query._id
+  } else {
+    query._id = { $nin: ids }
+  }
+}

package/lib/utils.js

@@ -1,6 +1,7 @@
 export { default as ContentTree } from './ContentTree.js'
 export { default as buildAssetUsagePipeline } from './utils/buildAssetUsagePipeline.js'
 export { default as computeSortOrderOps } from './utils/computeSortOrderOps.js'
+export { excludeIdsFromQuery } from './utils/excludeIdsFromQuery.js'
 export { extractAssetIds } from './utils/extractAssetIds.js'
 export { default as contentTypeToSchemaName } from './utils/contentTypeToSchemaName.js'
 export { default as fieldsToProjection } from './utils/fieldsToProjection.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-content",
-  "version": "3.2.4",
+  "version": "3.4.0",
   "description": "Module for managing Adapt content",
   "homepage": "https://github.com/adapt-security/adapt-authoring-content",
   "license": "GPL-3.0",

package/tests/utils-excludeIdsFromQuery.spec.js

@@ -0,0 +1,40 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { excludeIdsFromQuery } from '../lib/utils/excludeIdsFromQuery.js'
+
+describe('excludeIdsFromQuery', () => {
+  it('is a no-op for empty/falsy ids', () => {
+    const query = { type: 'image' }
+    excludeIdsFromQuery(query, [])
+    excludeIdsFromQuery(query, undefined)
+    assert.deepEqual(query, { type: 'image' })
+  })
+
+  it('adds a $nin _id constraint when none exists', () => {
+    const query = { type: 'image' }
+    excludeIdsFromQuery(query, ['a', 'b'])
+    assert.deepEqual(query, { type: 'image', _id: { $nin: ['a', 'b'] } })
+  })
+
+  it('preserves an existing _id constraint via $and', () => {
+    const query = { _id: { $in: ['keep'] } }
+    excludeIdsFromQuery(query, ['drop'])
+    assert.deepEqual(query, {
+      $and: [
+        { _id: { $in: ['keep'] } },
+        { _id: { $nin: ['drop'] } }
+      ]
+    })
+    assert.ok(!('_id' in query))
+  })
+
+  it('appends to an existing $and', () => {
+    const query = { $and: [{ a: 1 }], _id: 'x' }
+    excludeIdsFromQuery(query, ['y'])
+    assert.deepEqual(query.$and, [
+      { a: 1 },
+      { _id: 'x' },
+      { _id: { $nin: ['y'] } }
+    ])
+  })
+})

package/tests/_ht.js

@@ -1,116 +0,0 @@
-import { describe, it, mock } from 'node:test'
-import assert from 'node:assert/strict'
-
-import ContentModule from '../lib/ContentModule.js'
-
-const COURSE_ID = '507f1f77bcf86cd799439011'
-
-function createMockCollection (overrides = {}) {
-  return {
-    findOne: mock.fn(async () => null),
-    updateOne: mock.fn(async () => {}),
-    findOneAndUpdate: mock.fn(async () => ({ seq: 1 })),
-    find: mock.fn(() => ({ toArray: mock.fn(async () => []) })),
-    deleteMany: mock.fn(async () => {}),
-    ...overrides
-  }
-}
-
-function createMockMongodb (collectionOverrides) {
-  const col = createMockCollection(collectionOverrides)
-  return { getCollection: mock.fn(() => col), collection: col }
-}
-
-function createInstance (overrides = {}) {
-  return {
-    schemaName: 'content',
-    collectionName: 'content',
-    counterCollectionName: 'contentcounters',
-    idInterval: 5,
-    contentplugin: { findOne: mock.fn(async () => null) },
-    jsonschema: { extendSchema: mock.fn() },
-    authored: { schemaName: 'authored' },
-    tags: { schemaExtensionName: 'tags' },
-    mongodb: createMockMongodb(),
-    find: mock.fn(async () => []),
-    findOne: mock.fn(async () => null),
-    ...overrides
-  }
-}
-
-describe('ContentModule', () => {
-  describe('handleTree', () => {
-    it('should return 304 when content has not been modified', async () => {
-      const lastModified = new Date('2025-01-01T00:00:00Z')
-      const inst = createInstance({
-        findOne: mock.fn(async () => ({ updatedAt: lastModified }))
-      })
-      let statusCode
-      let ended = false
-      const req = {
-        apiData: { query: { _courseId: COURSE_ID } },
-        headers: { 'if-modified-since': new Date('2025-01-02T00:00:00Z').toUTCString() }
-      }
-      const res = {
-        status: mock.fn(function (code) { statusCode = code; return this }),
-        end: mock.fn(() => { ended = true })
-      }
-      const next = mock.fn()
-      await ContentModule.prototype.handleTree.call(inst, req, res, next)
-      assert.equal(statusCode, 304)
-      assert.equal(ended, true)
-      assert.equal(next.mock.callCount(), 0)
-    })
-
-    it('should return items with _children when content has been modified', async () => {
-      const lastModified = new Date('2025-01-15T00:00:00Z')
-      const items = [
-        { _id: COURSE_ID, _type: 'course', _courseId: COURSE_ID },
-        { _id: 'page1', _type: 'page', _parentId: COURSE_ID, _courseId: COURSE_ID },
-        { _id: 'art1', _type: 'article', _parentId: 'page1', _courseId: COURSE_ID }
-      ]
-      const inst = createInstance({
-        findOne: mock.fn(async () => ({ updatedAt: lastModified })),
-        find: mock.fn(async () => items)
-      })
-      const req = {
-        apiData: { query: { _courseId: COURSE_ID } },
-        headers: {}
-      }
-      let responseData
-      let lastModifiedHeader
-      const res = {
-        set: mock.fn((key, val) => { if (key === 'Last-Modified') lastModifiedHeader = val }),
-        json: mock.fn((data) => { responseData = data })
-      }
-      const next = mock.fn()
-      await ContentModule.prototype.handleTree.call(inst, req, res, next)
-
-      assert.equal(next.mock.callCount(), 0)
-      assert.equal(responseData.length, 3)
-      // course should have page1 as child
-      const course = responseData.find(i => i._id === COURSE_ID)
-      assert.deepEqual(course._children, ['page1'])
-      // page should have art1 as child
-      const page = responseData.find(i => i._id === 'page1')
-      assert.deepEqual(page._children, ['art1'])
-      // article should have no children
-      const art = responseData.find(i => i._id === 'art1')
-      assert.deepEqual(art._children, [])
-      // Last-Modified header should be set
-      assert.equal(lastModifiedHeader, lastModified.toUTCString())
-    })
-
-    it('should call next on error', async () => {
-      const inst = createInstance({
-        findOne: mock.fn(async () => { throw new Error('db error') })
-      })
-      const req = { apiData: { query: { _courseId: COURSE_ID } }, headers: {} }
-      const res = {}
-      const next = mock.fn()
-      await ContentModule.prototype.handleTree.call(inst, req, res, next)
-      assert.equal(next.mock.callCount(), 1)
-      assert.equal(next.mock.calls[0].arguments[0].message, 'db error')
-    })
-  })
-})