adapt-authoring-api 3.3.0 → 3.5.0

package/lib/AbstractApiModule.js

@@ -1,7 +1,6 @@
 import _ from 'lodash'
-import { AbstractModule, Hook, stringifyValues } from 'adapt-authoring-core'
+import { AbstractModule, DataCache, Hook, stringifyValues } from 'adapt-authoring-core'
 import { argsFromReq, generateApiMetadata, httpMethodToDBFunction } from './utils.js'
-import DataCache from './DataCache.js'
 import { loadRouteConfig } from 'adapt-authoring-server'
 /**
  * Abstract module for creating APIs
@@ -538,6 +537,10 @@ class AbstractApiModule extends AbstractModule {
    * @param {Object} mongoOpts The MongoDB options
    */
   async setUpPagination (req, res, mongoOpts) {
+    if (mongoOpts.limit === 0) {
+      delete mongoOpts.limit
+      return
+    }
     const maxPageSize = this.getConfig('maxPageSize') ?? this.app.config.get('adapt-authoring-api.maxPageSize')
     let pageSize = mongoOpts.limit ?? this.getConfig('defaultPageSize') ?? this.app.config.get('adapt-authoring-api.defaultPageSize')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-api",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "Abstract module for creating APIs",
   "homepage": "https://github.com/adapt-security/adapt-authoring-api",
   "license": "GPL-3.0",
@@ -11,7 +11,7 @@
     "test": "node --test 'tests/**/*.spec.js'"
   },
   "dependencies": {
-    "adapt-authoring-core": "^2.0.0",
+    "adapt-authoring-core": "^2.5.0",
     "adapt-authoring-server": "^2.1.0",
     "lodash": "^4.17.21"
   },

package/tests/AbstractApiModule.spec.js

@@ -230,4 +230,69 @@ describe('AbstractApiModule', () => {
       assert.equal(queryRoute.modifying, false)
     })
   })
+
+  describe('#setUpPagination()', () => {
+    function createPaginationInstance (docCount = 0, config = {}) {
+      const headers = {}
+      const instance = createInstance({
+        getConfig: (key) => config[key],
+        app: {
+          config: {
+            get: (key) => {
+              const defaults = { 'adapt-authoring-api.defaultPageSize': 100, 'adapt-authoring-api.maxPageSize': 250 }
+              return defaults[key]
+            }
+          },
+          waitForModule: async () => ({
+            getCollection: () => ({
+              countDocuments: async () => docCount
+            })
+          })
+        }
+      })
+      const req = { originalUrl: '/api/content/query', query: {}, apiData: { collectionName: 'content', query: {} } }
+      const res = { set: (k, v) => { headers[k] = v } }
+      return { instance, req, res, headers }
+    }
+
+    it('should skip pagination when limit is 0', async () => {
+      const { instance, req, res, headers } = createPaginationInstance(500)
+      const mongoOpts = { limit: 0 }
+      await instance.setUpPagination(req, res, mongoOpts)
+      assert.equal(mongoOpts.limit, undefined)
+      assert.equal(headers['X-Adapt-Page'], undefined)
+      assert.equal(headers['X-Adapt-PageSize'], undefined)
+    })
+
+    it('should apply default pagination when limit is not 0', async () => {
+      const { instance, req, res, headers } = createPaginationInstance(50)
+      const mongoOpts = {}
+      await instance.setUpPagination(req, res, mongoOpts)
+      assert.equal(mongoOpts.limit, 100)
+      assert.equal(headers['X-Adapt-Page'], 1)
+      assert.equal(headers['X-Adapt-PageSize'], 100)
+    })
+
+    it('should set Link header when results span multiple pages', async () => {
+      const { instance, req, res, headers } = createPaginationInstance(250)
+      const mongoOpts = {}
+      await instance.setUpPagination(req, res, mongoOpts)
+      assert.ok(headers.Link)
+      assert.ok(headers.Link.includes('rel="next"'))
+    })
+
+    it('should not set Link header for single-page results', async () => {
+      const { instance, req, res, headers } = createPaginationInstance(50)
+      const mongoOpts = {}
+      await instance.setUpPagination(req, res, mongoOpts)
+      assert.equal(headers.Link, undefined)
+    })
+
+    it('should cap pageSize at maxPageSize', async () => {
+      const { instance, req, res, headers } = createPaginationInstance(500)
+      const mongoOpts = { limit: 999 }
+      await instance.setUpPagination(req, res, mongoOpts)
+      assert.equal(headers['X-Adapt-PageSize'], 250)
+    })
+  })
 })

package/lib/DataCache.js

@@ -1,45 +0,0 @@
-import { App } from 'adapt-authoring-core'
-/**
- * Time-limited data cache
- * @memberof api
- */
-class DataCache {
-  /** @override */
-  constructor ({ enable, lifespan }) {
-    this.isEnabled = enable === true
-    this.lifespan = lifespan ?? App.instance.config.get('adapt-authoring-api.defaultCacheLifespan')
-    this.cache = {}
-  }
-
-  /**
-   * Retrieve cached data, or run fresh query if no cache exists or cache is invalid
-   * @param {Object} query
-   * @param Object} options
-   * @param {Object} mongoOptions
-   * @returns {*} The cached data
-   */
-  async get (query, options, mongoOptions) {
-    const key = JSON.stringify(query) + JSON.stringify(options) + JSON.stringify(mongoOptions)
-    this.prune()
-    if (this.isEnabled && this.cache[key]) {
-      return this.cache[key].data
-    }
-    const mongodb = await App.instance.waitForModule('mongodb')
-    const data = await mongodb.find(options.collectionName, query, mongoOptions)
-    this.cache[key] = { data, timestamp: Date.now() }
-    return data
-  }
-
-  /**
-   * Removes invalid cache data
-   */
-  prune () {
-    Object.keys(this.cache).forEach(k => {
-      if (Date.now() > (this.cache[k].timestamp + this.lifespan)) {
-        delete this.cache[k]
-      }
-    })
-  }
-}
-
-export default DataCache

package/tests/DataCache.spec.js

@@ -1,47 +0,0 @@
-import { describe, it, before } from 'node:test'
-import assert from 'node:assert/strict'
-
-describe('DataCache', () => {
-  let DataCache
-
-  before(async () => {
-    // DataCache constructor references App.instance.config, so we need to
-    // dynamically import after ensuring no app instance is required for prune tests.
-    // We import the module directly and test what we can without the full app.
-    DataCache = (await import('../lib/DataCache.js')).default
-  })
-
-  describe('#prune()', () => {
-    it('should remove expired entries from the cache', () => {
-      const instance = Object.create(DataCache.prototype)
-      instance.lifespan = 100
-      instance.cache = {
-        expired: { data: [1], timestamp: Date.now() - 200 },
-        valid: { data: [2], timestamp: Date.now() }
-      }
-      instance.prune()
-      assert.equal(instance.cache.expired, undefined)
-      assert.ok(instance.cache.valid)
-    })
-
-    it('should keep entries that have not expired', () => {
-      const instance = Object.create(DataCache.prototype)
-      instance.lifespan = 10000
-      instance.cache = {
-        a: { data: [1], timestamp: Date.now() },
-        b: { data: [2], timestamp: Date.now() }
-      }
-      instance.prune()
-      assert.ok(instance.cache.a)
-      assert.ok(instance.cache.b)
-    })
-
-    it('should handle an empty cache', () => {
-      const instance = Object.create(DataCache.prototype)
-      instance.lifespan = 100
-      instance.cache = {}
-      instance.prune()
-      assert.deepEqual(instance.cache, {})
-    })
-  })
-})