adapt-authoring-mongodb 3.0.1 → 3.1.0

package/lib/MongoDBModule.js

@@ -1,6 +1,7 @@
 import { AbstractModule } from 'adapt-authoring-core'
 import { MongoClient } from 'mongodb'
 import { convertObjectIds } from './utils/convertObjectIds.js'
+import { findDuplicates } from './utils/findDuplicates.js'
 import { isValidObjectId } from './utils/isValidObjectId.js'
 import { parseObjectId } from './utils/parseObjectId.js'
 /**
@@ -67,7 +68,29 @@ class MongoDBModule extends AbstractModule {
     try {
       await this.getCollection(collectionName).createIndex(fieldOrSpec, options)
     } catch (e) {
-      this.log('warn', e.toString())
+      if (e.code === 11000) {
+        await this.logDuplicateIndexError(collectionName, fieldOrSpec, e)
+      } else {
+        this.log('warn', e.toString())
+      }
+    }
+  }
+
+  /**
+   * Logs detailed information about duplicate index errors
+   * @param {String} collectionName The name of the MongoDB collection
+   * @param {String|Array|Object} fieldOrSpec Definition of the index
+   * @param {Error} error The original MongoDB error
+   */
+  async logDuplicateIndexError (collectionName, fieldOrSpec, error) {
+    this.log('warn', `Duplicate index error on '${collectionName}': ${error.message}`)
+    try {
+      const duplicates = await findDuplicates(this.getCollection(collectionName), fieldOrSpec)
+      for (const { keyValue, _ids } of duplicates) {
+        this.log('warn', `  ${JSON.stringify(keyValue)} → [${_ids.join(', ')}]`)
+      }
+    } catch (queryError) {
+      this.log('warn', `  Could not query duplicates: ${queryError.message}`)
     }
   }
 
@@ -94,18 +117,20 @@ class MongoDBModule extends AbstractModule {
    * Adds a new object to the database
    * @param {String} collectionName The name of the MongoDB collection
    * @param {Object} data
-   * @param {external:MongoDBInsertOneOptions} options Options to pass to the MongoDB driver
+   * @param {Object} options Options to pass to the MongoDB driver
+   * @param {Boolean} [options.preserveId] If true, retains a pre-set data._id instead of auto-generating one
    * @return {Promise} promise
    * @see https://mongodb.github.io/node-mongodb-native/4.2/classes/Collection.html#insertOne
    */
-  async insert (collectionName, data, options) {
+  async insert (collectionName, data, options = {}) {
+    const { preserveId, ...mongoOptions } = options
     convertObjectIds(data)
-    this.parseOptions(options)
-    // MongoDB doesn't like the explicit setting of _id
-    delete data._id
-    if (data.$set) delete data.$set._id
+    this.parseOptions(mongoOptions)
+    if (!preserveId) {
+      delete data._id
+    }
     try {
-      const { insertedId } = await this.getCollection(collectionName).insertOne(data, options)
+      const { insertedId } = await this.getCollection(collectionName).insertOne(data, mongoOptions)
       const [doc] = await this.find(collectionName, { _id: insertedId })
       return doc
     } catch (e) {

package/lib/utils/findDuplicates.js

@@ -0,0 +1,25 @@
+/**
+ * Finds documents with duplicate values for the given index fields.
+ * @param {import('mongodb').Collection} collection The MongoDB collection to search
+ * @param {String|Object} fieldOrSpec The index field spec (string key or object with field:direction pairs)
+ * @returns {Promise<Array<{keyValue: Object, _ids: Array}>>} Array of duplicate groups
+ */
+export async function findDuplicates (collection, fieldOrSpec) {
+  const fields = getFieldNames(fieldOrSpec)
+  const groupId = Object.fromEntries(fields.map(f => [f, `$${f}`]))
+  return collection.aggregate([
+    { $group: { _id: groupId, _ids: { $push: '$_id' }, count: { $sum: 1 } } },
+    { $match: { count: { $gt: 1 } } },
+    { $project: { _id: 0, keyValue: '$_id', _ids: 1 } }
+  ]).toArray()
+}
+
+/**
+ * Normalises a fieldOrSpec value into an array of field name strings.
+ * @param {String|Object} fieldOrSpec
+ * @returns {String[]}
+ */
+export function getFieldNames (fieldOrSpec) {
+  if (typeof fieldOrSpec === 'string') return [fieldOrSpec]
+  return Object.keys(fieldOrSpec)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-mongodb",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "Module for saving to a MongoDB instance",
   "homepage": "https://github.com/adapt-security/adapt-authoring-mongodb",
   "license": "GPL-3.0",

package/tests/insert.spec.js

@@ -0,0 +1,67 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+
+describe('insert() preserveId', () => {
+  const presetId = new ObjectId()
+  const generatedId = new ObjectId()
+
+  function createContext () {
+    let insertedData
+    return {
+      context: {
+        getCollection: mock.fn(() => ({
+          insertOne: mock.fn(async (data) => {
+            insertedData = { ...data }
+            return { insertedId: data._id ?? generatedId }
+          })
+        })),
+        find: mock.fn(async () => [{ _id: generatedId, name: 'test' }])
+      },
+      getInsertedData: () => insertedData
+    }
+  }
+
+  async function insert (context, collectionName, data, options = {}) {
+    const { preserveId, ...mongoOptions } = options
+    if (!preserveId) {
+      delete data._id
+      if (data.$set) delete data.$set._id
+    }
+    const { insertedId } = await context.getCollection(collectionName).insertOne(data, mongoOptions)
+    const [doc] = await context.find(collectionName, { _id: insertedId })
+    return doc
+  }
+
+  it('should strip _id by default', async () => {
+    const { context, getInsertedData } = createContext()
+    await insert(context, 'test', { _id: presetId, name: 'test' })
+    assert.equal(getInsertedData()._id, undefined)
+  })
+
+  it('should strip _id from $set by default', async () => {
+    const { context, getInsertedData } = createContext()
+    await insert(context, 'test', { $set: { _id: presetId, name: 'test' } })
+    assert.equal(getInsertedData().$set._id, undefined)
+  })
+
+  it('should preserve _id when preserveId is true', async () => {
+    const { context, getInsertedData } = createContext()
+    await insert(context, 'test', { _id: presetId, name: 'test' }, { preserveId: true })
+    assert.deepEqual(getInsertedData()._id, presetId)
+  })
+
+  it('should not pass preserveId to the MongoDB driver', async () => {
+    const { context } = createContext()
+    await insert(context, 'test', { _id: presetId, name: 'test' }, { preserveId: true })
+    const insertOne = context.getCollection.mock.calls[0].result.insertOne
+    const driverOptions = insertOne.mock.calls[0].arguments[1]
+    assert.equal(driverOptions?.preserveId, undefined)
+  })
+
+  it('should return the inserted document', async () => {
+    const { context } = createContext()
+    const result = await insert(context, 'test', { name: 'test' })
+    assert.deepEqual(result, { _id: generatedId, name: 'test' })
+  })
+})

package/tests/utils-findDuplicates.spec.js

@@ -0,0 +1,36 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { findDuplicates, getFieldNames } from '../lib/utils/findDuplicates.js'
+
+describe('getFieldNames()', () => {
+  it('should return a single-element array for a string input', () => {
+    assert.deepEqual(getFieldNames('email'), ['email'])
+  })
+
+  it('should return the keys of an object input', () => {
+    assert.deepEqual(getFieldNames({ _courseId: 1, _friendlyId: 1 }), ['_courseId', '_friendlyId'])
+  })
+})
+
+describe('findDuplicates()', () => {
+  function mockCollection (aggregateResult) {
+    return {
+      aggregate () {
+        return { toArray: async () => aggregateResult }
+      }
+    }
+  }
+
+  it('should return duplicate groups from the collection', async () => {
+    const expected = [
+      { keyValue: { email: 'a@b.com' }, _ids: ['id1', 'id2'] }
+    ]
+    const result = await findDuplicates(mockCollection(expected), 'email')
+    assert.deepEqual(result, expected)
+  })
+
+  it('should return an empty array when no duplicates exist', async () => {
+    const result = await findDuplicates(mockCollection([]), 'email')
+    assert.deepEqual(result, [])
+  })
+})