adapt-authoring-mongodb 1.1.4 → 2.0.0

package/.github/workflows/tests.yml

@@ -0,0 +1,15 @@
+name: Tests
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/index.js

@@ -3,4 +3,5 @@
  * @namespace mongodb
  */
 export { default as ObjectIdUtils } from './lib/ObjectIdUtils.js'
+export { create, isObjectId, isValid, parse, parseIds } from './lib/utils.js'
 export { default } from './lib/MongoDBModule.js'

package/lib/MongoDBModule.js

@@ -1,6 +1,7 @@
 import { AbstractModule } from 'adapt-authoring-core'
 import { MongoClient } from 'mongodb'
 import ObjectIdUtils from './ObjectIdUtils.js'
+import { parseIds } from './utils/parseIds.js'
 /**
  * Represents a single MongoDB server instance
  * @memberof mongodb
@@ -98,7 +99,7 @@ class MongoDBModule extends AbstractModule {
    * @see https://mongodb.github.io/node-mongodb-native/4.2/classes/Collection.html#insertOne
    */
   async insert (collectionName, data, options) {
-    this.ObjectId.parseIds(data)
+    parseIds(data)
     this.parseOptions(options)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
@@ -122,7 +123,7 @@ class MongoDBModule extends AbstractModule {
    * @see https://mongodb.github.io/node-mongodb-native/4.2/classes/Collection.html#find
    */
   async find (collectionName, query, options) {
-    this.ObjectId.parseIds(query)
+    parseIds(query)
     this.parseOptions(options)
     try {
       const cursor = this.getCollection(collectionName).find(query, options)
@@ -145,8 +146,8 @@ class MongoDBModule extends AbstractModule {
   async update (collectionName, query, data, options) {
     const opts = Object.assign({ includeResultMetadata: false, returnDocument: 'after' }, options)
     this.parseOptions(opts)
-    this.ObjectId.parseIds(query)
-    this.ObjectId.parseIds(data)
+    parseIds(query)
+    parseIds(data)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
     if (data.$set) delete data.$set._id
@@ -168,8 +169,8 @@ class MongoDBModule extends AbstractModule {
    */
   async updateMany (collectionName, query, data, options) {
     this.parseOptions(options)
-    this.ObjectId.parseIds(query)
-    this.ObjectId.parseIds(data)
+    parseIds(query)
+    parseIds(data)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
     if (data.$set) delete data.$set._id
@@ -193,8 +194,8 @@ class MongoDBModule extends AbstractModule {
    */
   async replace (collectionName, query, data, options) {
     const opts = Object.assign({ includeResultMetadata: false, returnDocument: 'after' }, options)
-    this.ObjectId.parseIds(query)
-    this.ObjectId.parseIds(data)
+    parseIds(query)
+    parseIds(data)
     this.parseOptions(options)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
@@ -216,7 +217,7 @@ class MongoDBModule extends AbstractModule {
    * @see https://mongodb.github.io/node-mongodb-native/4.2/classes/Collection.html#deleteOne
    */
   async delete (collectionName, query, options) {
-    this.ObjectId.parseIds(query)
+    parseIds(query)
     this.parseOptions(options)
     try {
       await this.getCollection(collectionName).deleteOne(query, options)
@@ -235,7 +236,7 @@ class MongoDBModule extends AbstractModule {
    * @see https://mongodb.github.io/node-mongodb-native/4.2/classes/Collection.html#deleteMany
    */
   async deleteMany (collectionName, query, options) {
-    this.ObjectId.parseIds(query)
+    parseIds(query)
     this.parseOptions(options)
     try {
       await this.getCollection(collectionName).deleteMany(query, options)
@@ -258,14 +259,6 @@ class MongoDBModule extends AbstractModule {
     else if (error.code === 11000) e = this.app.errors.MONGO_DUPL_INDEX
     return e.setData({ collectionName, action, error: error.message })
   }
-
-  /**
-   * ObjectId utility functions
-   * @type {ObjectIdUtils}
-   */
-  get ObjectId () {
-    return ObjectIdUtils
-  }
 }
 
 export default MongoDBModule

package/lib/ObjectIdUtils.js

@@ -1,7 +1,9 @@
-import { App, Utils } from 'adapt-authoring-core'
-import { ObjectId } from 'mongodb'
+import { App } from 'adapt-authoring-core'
+import { isValid } from './utils/isValid.js'
+import { parse } from './utils/parse.js'
+
 /**
- * Utility functions for dealing with MongoDB ObjectIds
+ * JSON schema integration for MongoDB ObjectIds
  * @memberof mongodb
  */
 class ObjectIdUtils {
@@ -17,11 +19,11 @@ class ObjectIdUtils {
       schemaType: 'boolean',
       compile: () => {
         return (value, { parentData, parentDataProperty }) => {
-          if (!ObjectIdUtils.isValid(value)) {
+          if (!isValid(value)) {
             return false
           }
           try {
-            parentData[parentDataProperty] = ObjectIdUtils.parse(value)
+            parentData[parentDataProperty] = parse(value)
           } catch (e) {
             return false
           }
@@ -30,73 +32,6 @@ class ObjectIdUtils {
       }
     })
   }
-
-  /**
-   * Creates a new ObjectId instance
-   * @return {external:MongoDBObjectId}
-   */
-  static create () {
-    return new ObjectId()
-  }
-
-  /**
-   * Checks a string is a valid ObjectId
-   * @param {String} s String to check
-   * @return {Boolean}
-   */
-  static isValid (s) {
-    try {
-      return ObjectIdUtils.parse(s).equals(s)
-    } catch (e) {
-      return false
-    }
-  }
-
-  /**
-   * Converts a string to an ObjectId
-   * @param {String} s The string to convert
-   * @return {external:MongoDBObjectId} The converted ID
-   * @throws {Error}
-   */
-  static parse (s) {
-    if (ObjectIdUtils.isObjectId(s)) {
-      return s
-    }
-    if (!ObjectId.isValid(s)) {
-      throw App.instance.errors.INVALID_OBJECTID.setData({ value: s })
-    }
-    return new ObjectId(s)
-  }
-
-  /**
-   * Checks an input object for any strings which pass the parse check and convert matches to ObjectId instances
-   * @param {Object} o Object to be checked
-   */
-  static parseIds (o) {
-    if (o === undefined) {
-      return
-    }
-    Object.entries(o).forEach(([k, v]) => {
-      if (Utils.isObject(v)) {
-        this.parseIds(v)
-      } else if (Array.isArray(v)) {
-        v.forEach((v2, i) => {
-          try {
-            if (typeof v2 === 'string') v[i] = this.parse(v2)
-          } catch (e) {} // ignore failures
-          this.parseIds(v2)
-        })
-      } else if (typeof v === 'string' && this.isValid(v)) {
-        try {
-          o[k] = this.parse(v)
-        } catch (e) {} // ignore failures
-      }
-    })
-  }
-
-  static isObjectId (data) {
-    return data instanceof ObjectId
-  }
 }
 
 export default ObjectIdUtils

package/lib/utils/create.js

@@ -0,0 +1,10 @@
+import { ObjectId } from 'mongodb'
+
+/**
+ * Creates a new ObjectId instance
+ * @return {external:MongoDBObjectId}
+ * @memberof mongodb
+ */
+export function create () {
+  return new ObjectId()
+}

package/lib/utils/isObjectId.js

@@ -0,0 +1,11 @@
+import { ObjectId } from 'mongodb'
+
+/**
+ * Checks if a value is a MongoDB ObjectId instance
+ * @param {*} data The value to check
+ * @return {Boolean}
+ * @memberof mongodb
+ */
+export function isObjectId (data) {
+  return data instanceof ObjectId
+}

package/lib/utils/isValid.js

@@ -0,0 +1,15 @@
+import { parse } from './parse.js'
+
+/**
+ * Checks a string is a valid ObjectId
+ * @param {String} s String to check
+ * @return {Boolean}
+ * @memberof mongodb
+ */
+export function isValid (s) {
+  try {
+    return parse(s).equals(s)
+  } catch (e) {
+    return false
+  }
+}

package/lib/utils/parse.js

@@ -0,0 +1,20 @@
+import { App } from 'adapt-authoring-core'
+import { ObjectId } from 'mongodb'
+import { isObjectId } from './isObjectId.js'
+
+/**
+ * Converts a string to an ObjectId
+ * @param {String} s The string to convert
+ * @return {external:MongoDBObjectId} The converted ID
+ * @throws {Error}
+ * @memberof mongodb
+ */
+export function parse (s) {
+  if (isObjectId(s)) {
+    return s
+  }
+  if (!ObjectId.isValid(s)) {
+    throw App.instance.errors.INVALID_OBJECTID.setData({ value: s })
+  }
+  return new ObjectId(s)
+}

package/lib/utils/parseIds.js

@@ -0,0 +1,30 @@
+import { isObject } from 'adapt-authoring-core'
+import { isValid } from './isValid.js'
+import { parse } from './parse.js'
+
+/**
+ * Checks an input object for any strings which pass the parse check and convert matches to ObjectId instances
+ * @param {Object} o Object to be checked
+ * @memberof mongodb
+ */
+export function parseIds (o) {
+  if (o === undefined) {
+    return
+  }
+  Object.entries(o).forEach(([k, v]) => {
+    if (isObject(v)) {
+      parseIds(v)
+    } else if (Array.isArray(v)) {
+      v.forEach((v2, i) => {
+        try {
+          if (typeof v2 === 'string') v[i] = parse(v2)
+        } catch (e) {} // ignore failures
+        parseIds(v2)
+      })
+    } else if (typeof v === 'string' && isValid(v)) {
+      try {
+        o[k] = parse(v)
+      } catch (e) {} // ignore failures
+    }
+  })
+}

package/lib/utils.js

@@ -0,0 +1,5 @@
+export { create } from './utils/create.js'
+export { isObjectId } from './utils/isObjectId.js'
+export { isValid } from './utils/isValid.js'
+export { parse } from './utils/parse.js'
+export { parseIds } from './utils/parseIds.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-mongodb",
-  "version": "1.1.4",
+  "version": "2.0.0",
   "description": "Module for saving to a MongoDB instance",
   "homepage": "https://github.com/adapt-security/adapt-authoring-mongodb",
   "license": "GPL-3.0",
@@ -8,12 +8,13 @@
   "main": "index.js",
   "repository": "github:adapt-security/adapt-authoring-mongodb",
   "dependencies": {
+    "adapt-authoring-core": "^2.0.0",
     "mongodb": "^7.0.0"
   },
   "peerDependencies": {
-    "adapt-authoring-config": "^1.1.4",
-    "adapt-authoring-core": "^1.7.0",
-    "adapt-authoring-jsonschema": "^1.2.0"
+    "adapt-authoring-config": "^1.3.0",
+    "adapt-authoring-core": "^2.0.0",
+    "adapt-authoring-jsonschema": "^1.2.2"
   },
   "peerDependenciesMeta": {
     "adapt-authoring-config": {
@@ -58,5 +59,8 @@
         }
       ]
     ]
+  },
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
   }
 }

package/tests/MongoDBModule.spec.js

@@ -0,0 +1,104 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import MongoDBModule from '../lib/MongoDBModule.js'
+
+/**
+ * MongoDBModule extends AbstractModule and requires a running MongoDB connection.
+ * We test parseOptions and getError in isolation.
+ */
+
+function createInstance () {
+  const mockApp = {
+    waitForModule: mock.fn(async () => {}),
+    errors: {
+      MONGO_ERROR: { setData: mock.fn(function (d) { return { code: 'MONGO_ERROR', ...d } }) },
+      MONGO_IMMUTABLE_FIELD: { setData: mock.fn(function (d) { return { code: 'MONGO_IMMUTABLE_FIELD', ...d } }) },
+      MONGO_DUPL_INDEX: { setData: mock.fn(function (d) { return { code: 'MONGO_DUPL_INDEX', ...d } }) },
+      MONGO_CONN_FAILED: { setData: mock.fn(function () { return this }) }
+    },
+    dependencyloader: {
+      moduleLoadedHook: { tap: () => {}, untap: () => {} }
+    }
+  }
+
+  const originalInit = MongoDBModule.prototype.init
+  MongoDBModule.prototype.init = async function () {}
+
+  const instance = new MongoDBModule(mockApp, { name: 'adapt-authoring-mongodb' })
+
+  MongoDBModule.prototype.init = originalInit
+
+  instance.log = mock.fn()
+
+  return { instance, mockApp }
+}
+
+describe('MongoDBModule', () => {
+  describe('#parseOptions()', () => {
+    it('should parse string limit to integer', () => {
+      const { instance } = createInstance()
+      const options = { limit: '10' }
+      instance.parseOptions(options)
+      assert.equal(options.limit, 10)
+    })
+
+    it('should parse string skip to integer', () => {
+      const { instance } = createInstance()
+      const options = { skip: '5' }
+      instance.parseOptions(options)
+      assert.equal(options.skip, 5)
+    })
+
+    it('should handle undefined options gracefully', () => {
+      const { instance } = createInstance()
+      instance.parseOptions(undefined)
+    })
+
+    it('should handle options without limit or skip', () => {
+      const { instance } = createInstance()
+      const options = { sort: { name: 1 } }
+      instance.parseOptions(options)
+      assert.deepEqual(options, { sort: { name: 1 } })
+    })
+
+    it('should keep numeric limit as-is', () => {
+      const { instance } = createInstance()
+      const options = { limit: 10 }
+      instance.parseOptions(options)
+      assert.equal(options.limit, 10)
+    })
+
+    it('should skip undefined limit', () => {
+      const { instance } = createInstance()
+      const options = { limit: undefined }
+      instance.parseOptions(options)
+      assert.equal(options.limit, undefined)
+    })
+  })
+
+  describe('#getError()', () => {
+    it('should return MONGO_IMMUTABLE_FIELD for error code 66', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'update', { code: 66, message: 'immutable' })
+      assert.equal(result.code, 'MONGO_IMMUTABLE_FIELD')
+    })
+
+    it('should return MONGO_DUPL_INDEX for error code 11000', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'insert', { code: 11000, message: 'duplicate' })
+      assert.equal(result.code, 'MONGO_DUPL_INDEX')
+    })
+
+    it('should return MONGO_ERROR for other error codes', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'find', { code: 999, message: 'unknown' })
+      assert.equal(result.code, 'MONGO_ERROR')
+    })
+
+    it('should return MONGO_ERROR for errors without code', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'delete', { message: 'fail' })
+      assert.equal(result.code, 'MONGO_ERROR')
+    })
+  })
+})

package/tests/utils-create.spec.js

@@ -0,0 +1,22 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+import { create } from '../lib/utils/create.js'
+
+describe('create()', () => {
+  it('should return an ObjectId instance', () => {
+    const id = create()
+    assert.ok(id instanceof ObjectId)
+  })
+
+  it('should create unique IDs each time', () => {
+    const id1 = create()
+    const id2 = create()
+    assert.notEqual(id1.toString(), id2.toString())
+  })
+
+  it('should return a 24-character hex string representation', () => {
+    const id = create()
+    assert.match(id.toString(), /^[0-9a-f]{24}$/)
+  })
+})

package/tests/utils-isObjectId.spec.js

@@ -0,0 +1,38 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+import { isObjectId } from '../lib/utils/isObjectId.js'
+
+describe('isObjectId()', () => {
+  it('should return true for an ObjectId instance', () => {
+    assert.equal(isObjectId(new ObjectId()), true)
+  })
+
+  it('should return false for a valid ObjectId string', () => {
+    assert.equal(isObjectId('507f1f77bcf86cd799439011'), false)
+  })
+
+  it('should return false for a plain string', () => {
+    assert.equal(isObjectId('hello'), false)
+  })
+
+  it('should return false for null', () => {
+    assert.equal(isObjectId(null), false)
+  })
+
+  it('should return false for undefined', () => {
+    assert.equal(isObjectId(undefined), false)
+  })
+
+  it('should return false for a number', () => {
+    assert.equal(isObjectId(12345), false)
+  })
+
+  it('should return false for a plain object', () => {
+    assert.equal(isObjectId({}), false)
+  })
+
+  it('should return false for an array', () => {
+    assert.equal(isObjectId([]), false)
+  })
+})

package/tests/utils-isValid.spec.js

@@ -0,0 +1,53 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+import App from 'adapt-authoring-core/lib/App.js'
+
+mock.getter(App, 'instance', () => ({
+  errors: {
+    INVALID_OBJECTID: {
+      setData (data) {
+        const e = new Error('INVALID_OBJECTID')
+        e.data = data
+        return e
+      }
+    }
+  }
+}))
+
+const { isValid } = await import('../lib/utils/isValid.js')
+
+describe('isValid()', () => {
+  it('should return true for a valid ObjectId string', () => {
+    const id = new ObjectId()
+    assert.equal(isValid(id.toString()), true)
+  })
+
+  it('should return true for a 24-char hex string', () => {
+    assert.equal(isValid('507f1f77bcf86cd799439011'), true)
+  })
+
+  it('should return false for a random string', () => {
+    assert.equal(isValid('not-an-objectid'), false)
+  })
+
+  it('should return false for an empty string', () => {
+    assert.equal(isValid(''), false)
+  })
+
+  it('should return false for a number', () => {
+    assert.equal(isValid(12345), false)
+  })
+
+  it('should return false for a 23-char hex string', () => {
+    assert.equal(isValid('507f1f77bcf86cd79943901'), false)
+  })
+
+  it('should return false for null', () => {
+    assert.equal(isValid(null), false)
+  })
+
+  it('should return false for undefined', () => {
+    assert.equal(isValid(undefined), false)
+  })
+})

package/tests/utils-parse.spec.js

@@ -0,0 +1,70 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+import App from 'adapt-authoring-core/lib/App.js'
+
+mock.getter(App, 'instance', () => ({
+  errors: {
+    INVALID_OBJECTID: {
+      setData (data) {
+        const e = new Error('INVALID_OBJECTID')
+        e.data = data
+        return e
+      }
+    }
+  }
+}))
+
+const { parse } = await import('../lib/utils/parse.js')
+
+describe('parse()', () => {
+  it('should return same ObjectId if already an ObjectId instance', () => {
+    const id = new ObjectId()
+    assert.equal(parse(id), id)
+  })
+
+  it('should convert a valid ObjectId string to an ObjectId', () => {
+    const str = '507f1f77bcf86cd799439011'
+    const result = parse(str)
+    assert.ok(result instanceof ObjectId)
+    assert.equal(result.toString(), str)
+  })
+
+  it('should throw INVALID_OBJECTID for an invalid string', () => {
+    assert.throws(
+      () => parse('not-a-valid-id'),
+      (err) => {
+        assert.equal(err.message, 'INVALID_OBJECTID')
+        assert.deepEqual(err.data, { value: 'not-a-valid-id' })
+        return true
+      }
+    )
+  })
+
+  it('should throw INVALID_OBJECTID for an empty string', () => {
+    assert.throws(
+      () => parse(''),
+      (err) => {
+        assert.equal(err.message, 'INVALID_OBJECTID')
+        return true
+      }
+    )
+  })
+
+  it('should convert a 24-char hex string', () => {
+    const hex = 'aabbccddeeff00112233aabb'
+    const result = parse(hex)
+    assert.ok(result instanceof ObjectId)
+    assert.equal(result.toString(), hex)
+  })
+
+  it('should throw for a 23-char string', () => {
+    assert.throws(
+      () => parse('507f1f77bcf86cd79943901'),
+      (err) => {
+        assert.equal(err.message, 'INVALID_OBJECTID')
+        return true
+      }
+    )
+  })
+})

package/tests/utils-parseIds.spec.js

@@ -0,0 +1,110 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+import App from 'adapt-authoring-core/lib/App.js'
+
+mock.getter(App, 'instance', () => ({
+  errors: {
+    INVALID_OBJECTID: {
+      setData (data) {
+        const e = new Error('INVALID_OBJECTID')
+        e.data = data
+        return e
+      }
+    }
+  }
+}))
+
+const { parseIds } = await import('../lib/utils/parseIds.js')
+
+describe('parseIds()', () => {
+  it('should handle undefined input gracefully', () => {
+    assert.equal(parseIds(undefined), undefined)
+  })
+
+  it('should convert valid ObjectId strings in a flat object', () => {
+    const idStr = new ObjectId().toString()
+    const obj = { _id: idStr }
+    parseIds(obj)
+    assert.ok(obj._id instanceof ObjectId)
+    assert.equal(obj._id.toString(), idStr)
+  })
+
+  it('should leave non-ObjectId strings unchanged', () => {
+    const obj = { name: 'test', value: 'hello' }
+    parseIds(obj)
+    assert.equal(obj.name, 'test')
+    assert.equal(obj.value, 'hello')
+  })
+
+  it('should recurse into nested objects', () => {
+    const idStr = new ObjectId().toString()
+    const obj = { nested: { _id: idStr } }
+    parseIds(obj)
+    assert.ok(obj.nested._id instanceof ObjectId)
+    assert.equal(obj.nested._id.toString(), idStr)
+  })
+
+  it('should convert ObjectId strings in arrays', () => {
+    const idStr = new ObjectId().toString()
+    const obj = { ids: [idStr] }
+    parseIds(obj)
+    assert.ok(obj.ids[0] instanceof ObjectId)
+    assert.equal(obj.ids[0].toString(), idStr)
+  })
+
+  it('should recurse into objects within arrays', () => {
+    const idStr = new ObjectId().toString()
+    const obj = { items: [{ _id: idStr }] }
+    parseIds(obj)
+    assert.ok(obj.items[0]._id instanceof ObjectId)
+  })
+
+  it('should leave non-ObjectId strings in arrays unchanged', () => {
+    const obj = { tags: ['hello', 'world'] }
+    parseIds(obj)
+    assert.equal(obj.tags[0], 'hello')
+    assert.equal(obj.tags[1], 'world')
+  })
+
+  it('should leave numbers and booleans unchanged', () => {
+    const obj = { count: 42, active: true }
+    parseIds(obj)
+    assert.equal(obj.count, 42)
+    assert.equal(obj.active, true)
+  })
+
+  it('should handle deeply nested structures', () => {
+    const idStr = new ObjectId().toString()
+    const obj = { a: { b: { c: { _id: idStr } } } }
+    parseIds(obj)
+    assert.ok(obj.a.b.c._id instanceof ObjectId)
+  })
+
+  it('should handle mixed content in an object', () => {
+    const idStr = new ObjectId().toString()
+    const obj = {
+      _id: idStr,
+      name: 'test',
+      count: 5,
+      nested: { value: 'keep' }
+    }
+    parseIds(obj)
+    assert.ok(obj._id instanceof ObjectId)
+    assert.equal(obj.name, 'test')
+    assert.equal(obj.count, 5)
+    assert.equal(obj.nested.value, 'keep')
+  })
+
+  it('should handle empty objects', () => {
+    const obj = {}
+    parseIds(obj)
+    assert.deepEqual(obj, {})
+  })
+
+  it('should handle objects with empty arrays', () => {
+    const obj = { items: [] }
+    parseIds(obj)
+    assert.deepEqual(obj.items, [])
+  })
+})