adapt-authoring-mongodb 3.0.1 → 3.2.0

package/.github/workflows/releases.yml

@@ -1,32 +1,17 @@
 name: Release
+
 on:
   push:
     branches:
       - master
 
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+  id-token: write
+  packages: write
+
 jobs:
   release:
-    name: Release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write # to be able to publish a GitHub release
-      issues: write # to be able to comment on released issues
-      pull-requests: write # to be able to comment on released pull requests
-      id-token: write # to enable use of OIDC for trusted publishing and npm provenance
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 'lts/*'
-      - name: Update npm
-        run: npm install -g npm@latest
-      - name: Install dependencies
-        run: npm install
-      - name: Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npx semantic-release
+    uses: adaptlearning/semantic-release-config/.github/workflows/release.yml@master

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'
 /**
@@ -11,7 +12,6 @@ import { parseObjectId } from './utils/parseObjectId.js'
 class MongoDBModule extends AbstractModule {
   /** @override */
   async init () {
-    await this.app.waitForModule('config')
     /**
      * Reference to the MongDB client
      * @type {external:MongoDBMongoClient}
@@ -67,7 +67,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 +116,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 {external:MongoDBCollection} 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.2.0",
   "description": "Module for saving to a MongoDB instance",
   "homepage": "https://github.com/adapt-security/adapt-authoring-mongodb",
   "license": "GPL-3.0",
@@ -8,46 +8,19 @@
   "main": "index.js",
   "repository": "github:adapt-security/adapt-authoring-mongodb",
   "dependencies": {
-    "adapt-authoring-core": "^2.0.0",
+    "adapt-authoring-core": "^3.0.0",
     "mongodb": "^7.0.0"
   },
   "peerDependencies": {
-    "adapt-authoring-config": "^1.3.0",
-    "adapt-authoring-core": "^2.0.0",
+    "adapt-authoring-core": "^3.0.0",
     "adapt-authoring-jsonschema": "^1.2.2"
   },
   "devDependencies": {
-    "@semantic-release/git": "^10.0.1",
-    "conventional-changelog-eslint": "^6.0.0",
-    "semantic-release": "^25.0.2",
+    "@adaptlearning/semantic-release-config": "^1.0.0",
     "standard": "^17.1.0"
   },
   "release": {
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "eslint"
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "eslint"
-        }
-      ],
-      "@semantic-release/npm",
-      "@semantic-release/github",
-      [
-        "@semantic-release/git",
-        {
-          "assets": [
-            "package.json"
-          ],
-          "message": "Chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-        }
-      ]
-    ]
+    "extends": "@adaptlearning/semantic-release-config"
   },
   "scripts": {
     "test": "node --test 'tests/**/*.spec.js'"

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, [])
+  })
+})