adapt-authoring-api 3.2.2 → 3.3.0

package/lib/AbstractApiModule.js

@@ -658,7 +658,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
@@ -726,7 +726,9 @@ class AbstractApiModule extends AbstractModule {
 
     const updatedDocs = await mongodb.updateMany(options.collectionName, query, formattedData, mongoOptions)
 
-    if (options.invokePostHook !== false) await Promise.all(updatedDocs.map(d => this.postUpdateHook.invoke(d, updatedDocs)))
+    if (options.invokePostHook !== false) {
+      await Promise.all(originalDocs.map((original, i) => this.postUpdateHook.invoke(original, updatedDocs[i])))
+    }
     return updatedDocs
   }
 
@@ -770,6 +772,8 @@ class AbstractApiModule extends AbstractModule {
 
     const mongodb = await this.app.waitForModule('mongodb')
     const toDelete = await mongodb.find(options.collectionName, query)
+
+    if (options.invokePreHook !== false) await Promise.all(toDelete.map(d => this.preDeleteHook.invoke(d, options, mongoOptions)))
     await mongodb.deleteMany(options.collectionName, query, mongoOptions)
 
     if (options.invokePostHook !== false) await Promise.all(toDelete.map(d => this.postDeleteHook.invoke(d)))

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.2",
+  "version": "3.3.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))