adapt-authoring-api 3.2.3 → 3.4.0

package/lib/AbstractApiModule.js

@@ -538,6 +538,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')
 
@@ -658,7 +662,7 @@ class AbstractApiModule extends AbstractModule {
     if (results.length > 1) {
       throw this.app.errors.TOO_MANY_RESULTS.setData({ actual: results.length, expected: 1, query })
     }
-    if (options.strict !== false && !results.length) {
+    if ((options.throwOnMissing ?? options.strict) !== false && !results.length) {
       throw this.app.errors.NOT_FOUND.setData({ id: query, type: options.schemaName })
     }
     return results[0] ?? null

package/lib/typedefs.js

@@ -49,6 +49,8 @@
  * @typedef {Object} FindOptions
  * @property {String} schemaName Name of the schema to validate against
  * @property {String} collectionName DB collection to insert document into
+ * @property {Boolean} throwOnMissing Whether to throw a NOT_FOUND error when no results are found (default: true)
+ * @property {Boolean} [strict] @deprecated Use throwOnMissing instead
  */
 /**
  * @memberof api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-api",
-  "version": "3.2.3",
+  "version": "3.4.0",
   "description": "Abstract module for creating APIs",
   "homepage": "https://github.com/adapt-security/adapt-authoring-api",
   "license": "GPL-3.0",

package/tests/AbstractApiModule.spec.js

@@ -142,6 +142,56 @@ describe('AbstractApiModule', () => {
     })
   })
 
+  describe('#findOne()', () => {
+    function createFindOneInstance (findResults) {
+      const notFoundError = { setData: () => { const e = new Error('NOT_FOUND'); e.code = 'NOT_FOUND'; return e } }
+      const tooManyResultsError = { setData: () => { const e = new Error('TOO_MANY_RESULTS'); e.code = 'TOO_MANY_RESULTS'; return e } }
+      const instance = Object.create(AbstractApiModule.prototype)
+      instance.find = async () => findResults
+      instance.app = { errors: { NOT_FOUND: notFoundError, TOO_MANY_RESULTS: tooManyResultsError } }
+      return instance
+    }
+
+    it('should throw NOT_FOUND when no results and throwOnMissing is not set', async () => {
+      const instance = createFindOneInstance([])
+      await assert.rejects(() => instance.findOne({}), /NOT_FOUND/)
+    })
+
+    it('should throw NOT_FOUND when no results and throwOnMissing is true', async () => {
+      const instance = createFindOneInstance([])
+      await assert.rejects(() => instance.findOne({}, { throwOnMissing: true }), /NOT_FOUND/)
+    })
+
+    it('should return null when no results and throwOnMissing is false', async () => {
+      const instance = createFindOneInstance([])
+      const result = await instance.findOne({}, { throwOnMissing: false })
+      assert.equal(result, null)
+    })
+
+    it('should return null when no results and strict is false (backward compat)', async () => {
+      const instance = createFindOneInstance([])
+      const result = await instance.findOne({}, { strict: false })
+      assert.equal(result, null)
+    })
+
+    it('should prefer throwOnMissing over strict when both are set', async () => {
+      const instance = createFindOneInstance([])
+      await assert.rejects(() => instance.findOne({}, { throwOnMissing: true, strict: false }), /NOT_FOUND/)
+    })
+
+    it('should return the single result when found', async () => {
+      const doc = { _id: '1', name: 'test' }
+      const instance = createFindOneInstance([doc])
+      const result = await instance.findOne({})
+      assert.deepEqual(result, doc)
+    })
+
+    it('should throw TOO_MANY_RESULTS when more than one result is returned', async () => {
+      const instance = createFindOneInstance([{ _id: '1' }, { _id: '2' }])
+      await assert.rejects(() => instance.findOne({}), /TOO_MANY_RESULTS/)
+    })
+  })
+
   describe('default-routes.json', () => {
     it('should define an array of route objects', () => {
       assert.ok(Array.isArray(defaultRoutes.routes))
@@ -180,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)
+    })
+  })
 })