adapt-authoring-mongodb 2.0.1 → 3.0.1

package/.github/workflows/standardjs.yml

@@ -1,4 +1,4 @@
-name: Standard.js formatting check
+name: Lint
 on: push
 jobs:
   default:
@@ -9,4 +9,4 @@ jobs:
         with:
           node-version: 'lts/*'
       - run: npm install
-      - run: npx standard
+      - run: npx standard

package/index.js

@@ -2,6 +2,5 @@
  * MongoDB integration
  * @namespace mongodb
  */
-export { default as ObjectIdUtils } from './lib/ObjectIdUtils.js'
-export { create, isObjectId, isValid, parse, parseIds } from './lib/utils.js'
+export { convertObjectIds, createObjectId, isObjectId, isValidObjectId, parseObjectId } from './lib/utils.js'
 export { default } from './lib/MongoDBModule.js'

package/lib/MongoDBModule.js

@@ -1,7 +1,8 @@
 import { AbstractModule } from 'adapt-authoring-core'
 import { MongoClient } from 'mongodb'
-import ObjectIdUtils from './ObjectIdUtils.js'
-import { parseIds } from './utils/parseIds.js'
+import { convertObjectIds } from './utils/convertObjectIds.js'
+import { isValidObjectId } from './utils/isValidObjectId.js'
+import { parseObjectId } from './utils/parseObjectId.js'
 /**
  * Represents a single MongoDB server instance
  * @memberof mongodb
@@ -17,8 +18,7 @@ class MongoDBModule extends AbstractModule {
      */
     this.client = new MongoClient(this.getConfig('connectionUri'), { ignoreUndefined: true })
     await this.connect()
-    // add custom keywords to JSON Schema validator
-    await ObjectIdUtils.addSchemaKeyword()
+    await this.addSchemaKeyword()
   }
 
   /**
@@ -99,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) {
-    parseIds(data)
+    convertObjectIds(data)
     this.parseOptions(options)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
@@ -123,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) {
-    parseIds(query)
+    convertObjectIds(query)
     this.parseOptions(options)
     try {
       const cursor = this.getCollection(collectionName).find(query, options)
@@ -146,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)
-    parseIds(query)
-    parseIds(data)
+    convertObjectIds(query)
+    convertObjectIds(data)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
     if (data.$set) delete data.$set._id
@@ -169,8 +169,8 @@ class MongoDBModule extends AbstractModule {
    */
   async updateMany (collectionName, query, data, options) {
     this.parseOptions(options)
-    parseIds(query)
-    parseIds(data)
+    convertObjectIds(query)
+    convertObjectIds(data)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
     if (data.$set) delete data.$set._id
@@ -194,8 +194,8 @@ class MongoDBModule extends AbstractModule {
    */
   async replace (collectionName, query, data, options) {
     const opts = Object.assign({ includeResultMetadata: false, returnDocument: 'after' }, options)
-    parseIds(query)
-    parseIds(data)
+    convertObjectIds(query)
+    convertObjectIds(data)
     this.parseOptions(options)
     // MongoDB doesn't like the explicit setting of _id
     delete data._id
@@ -217,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) {
-    parseIds(query)
+    convertObjectIds(query)
     this.parseOptions(options)
     try {
       await this.getCollection(collectionName).deleteOne(query, options)
@@ -236,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) {
-    parseIds(query)
+    convertObjectIds(query)
     this.parseOptions(options)
     try {
       await this.getCollection(collectionName).deleteMany(query, options)
@@ -246,6 +246,32 @@ class MongoDBModule extends AbstractModule {
     }
   }
 
+  /**
+   * Registers the isObjectId JSON schema keyword
+   */
+  async addSchemaKeyword () {
+    const jsonschema = await this.app.waitForModule('jsonschema')
+    jsonschema.addKeyword({
+      keyword: 'isObjectId',
+      type: 'string',
+      modifying: true,
+      schemaType: 'boolean',
+      compile: () => {
+        return (value, { parentData, parentDataProperty }) => {
+          if (!isValidObjectId(value)) {
+            return false
+          }
+          try {
+            parentData[parentDataProperty] = parseObjectId(value)
+          } catch (e) {
+            return false
+          }
+          return true
+        }
+      }
+    }, { override: true })
+  }
+
   /**
    * Returns the relevant AdaptError instance to match the MongoError
    * @param {String} collectionName DB collection being processed

package/lib/utils/{parseIds.js → convertObjectIds.js}

@@ -1,29 +1,29 @@
 import { isObject } from 'adapt-authoring-core'
-import { isValid } from './isValid.js'
-import { parse } from './parse.js'
+import { isValidObjectId } from './isValidObjectId.js'
+import { parseObjectId } from './parseObjectId.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) {
+export function convertObjectIds (o) {
   if (o === undefined) {
     return
   }
   Object.entries(o).forEach(([k, v]) => {
     if (isObject(v)) {
-      parseIds(v)
+      convertObjectIds(v)
     } else if (Array.isArray(v)) {
       v.forEach((v2, i) => {
         try {
-          if (typeof v2 === 'string') v[i] = parse(v2)
+          if (typeof v2 === 'string') v[i] = parseObjectId(v2)
         } catch (e) {} // ignore failures
-        parseIds(v2)
+        convertObjectIds(v2)
       })
-    } else if (typeof v === 'string' && isValid(v)) {
+    } else if (typeof v === 'string' && isValidObjectId(v)) {
       try {
-        o[k] = parse(v)
+        o[k] = parseObjectId(v)
       } catch (e) {} // ignore failures
     }
   })

package/lib/utils/{create.js → createObjectId.js}

@@ -5,6 +5,6 @@ import { ObjectId } from 'mongodb'
  * @return {external:MongoDBObjectId}
  * @memberof mongodb
  */
-export function create () {
+export function createObjectId () {
   return new ObjectId()
 }

package/lib/utils/{isValid.js → isValidObjectId.js}

@@ -1,4 +1,4 @@
-import { parse } from './parse.js'
+import { parseObjectId } from './parseObjectId.js'
 
 /**
  * Checks a string is a valid ObjectId
@@ -6,9 +6,9 @@ import { parse } from './parse.js'
  * @return {Boolean}
  * @memberof mongodb
  */
-export function isValid (s) {
+export function isValidObjectId (s) {
   try {
-    return parse(s).equals(s)
+    return parseObjectId(s).equals(s)
   } catch (e) {
     return false
   }

package/lib/utils/{parse.js → parseObjectId.js}

@@ -9,7 +9,7 @@ import { isObjectId } from './isObjectId.js'
  * @throws {Error}
  * @memberof mongodb
  */
-export function parse (s) {
+export function parseObjectId (s) {
   if (isObjectId(s)) {
     return s
   }

package/lib/utils.js

@@ -1,5 +1,5 @@
-export { create } from './utils/create.js'
+export { createObjectId } from './utils/createObjectId.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'
+export { isValidObjectId } from './utils/isValidObjectId.js'
+export { parseObjectId } from './utils/parseObjectId.js'
+export { convertObjectIds } from './utils/convertObjectIds.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-mongodb",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "Module for saving to a MongoDB instance",
   "homepage": "https://github.com/adapt-security/adapt-authoring-mongodb",
   "license": "GPL-3.0",
@@ -16,17 +16,6 @@
     "adapt-authoring-core": "^2.0.0",
     "adapt-authoring-jsonschema": "^1.2.2"
   },
-  "peerDependenciesMeta": {
-    "adapt-authoring-config": {
-      "optional": true
-    },
-    "adapt-authoring-core": {
-      "optional": true
-    },
-    "adapt-authoring-jsonschema": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@semantic-release/git": "^10.0.1",
     "conventional-changelog-eslint": "^6.0.0",

package/tests/{utils-parseIds.spec.js → utils-convertObjectIds.spec.js}

@@ -15,24 +15,24 @@ mock.getter(App, 'instance', () => ({
   }
 }))
 
-const { parseIds } = await import('../lib/utils/parseIds.js')
+const { convertObjectIds } = await import('../lib/utils/convertObjectIds.js')
 
-describe('parseIds()', () => {
+describe('convertObjectIds()', () => {
   it('should handle undefined input gracefully', () => {
-    assert.equal(parseIds(undefined), undefined)
+    assert.equal(convertObjectIds(undefined), undefined)
   })
 
   it('should convert valid ObjectId strings in a flat object', () => {
     const idStr = new ObjectId().toString()
     const obj = { _id: idStr }
-    parseIds(obj)
+    convertObjectIds(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)
+    convertObjectIds(obj)
     assert.equal(obj.name, 'test')
     assert.equal(obj.value, 'hello')
   })
@@ -40,7 +40,7 @@ describe('parseIds()', () => {
   it('should recurse into nested objects', () => {
     const idStr = new ObjectId().toString()
     const obj = { nested: { _id: idStr } }
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.ok(obj.nested._id instanceof ObjectId)
     assert.equal(obj.nested._id.toString(), idStr)
   })
@@ -48,7 +48,7 @@ describe('parseIds()', () => {
   it('should convert ObjectId strings in arrays', () => {
     const idStr = new ObjectId().toString()
     const obj = { ids: [idStr] }
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.ok(obj.ids[0] instanceof ObjectId)
     assert.equal(obj.ids[0].toString(), idStr)
   })
@@ -56,20 +56,20 @@ describe('parseIds()', () => {
   it('should recurse into objects within arrays', () => {
     const idStr = new ObjectId().toString()
     const obj = { items: [{ _id: idStr }] }
-    parseIds(obj)
+    convertObjectIds(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)
+    convertObjectIds(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)
+    convertObjectIds(obj)
     assert.equal(obj.count, 42)
     assert.equal(obj.active, true)
   })
@@ -77,7 +77,7 @@ describe('parseIds()', () => {
   it('should handle deeply nested structures', () => {
     const idStr = new ObjectId().toString()
     const obj = { a: { b: { c: { _id: idStr } } } }
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.ok(obj.a.b.c._id instanceof ObjectId)
   })
 
@@ -89,7 +89,7 @@ describe('parseIds()', () => {
       count: 5,
       nested: { value: 'keep' }
     }
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.ok(obj._id instanceof ObjectId)
     assert.equal(obj.name, 'test')
     assert.equal(obj.count, 5)
@@ -98,13 +98,13 @@ describe('parseIds()', () => {
 
   it('should handle empty objects', () => {
     const obj = {}
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.deepEqual(obj, {})
   })
 
   it('should handle objects with empty arrays', () => {
     const obj = { items: [] }
-    parseIds(obj)
+    convertObjectIds(obj)
     assert.deepEqual(obj.items, [])
   })
 })

package/tests/{utils-create.spec.js → utils-createObjectId.spec.js}

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

package/tests/{utils-isValid.spec.js → utils-isValidObjectId.spec.js}

@@ -15,39 +15,39 @@ mock.getter(App, 'instance', () => ({
   }
 }))
 
-const { isValid } = await import('../lib/utils/isValid.js')
+const { isValidObjectId } = await import('../lib/utils/isValidObjectId.js')
 
-describe('isValid()', () => {
+describe('isValidObjectId()', () => {
   it('should return true for a valid ObjectId string', () => {
     const id = new ObjectId()
-    assert.equal(isValid(id.toString()), true)
+    assert.equal(isValidObjectId(id.toString()), true)
   })
 
   it('should return true for a 24-char hex string', () => {
-    assert.equal(isValid('507f1f77bcf86cd799439011'), true)
+    assert.equal(isValidObjectId('507f1f77bcf86cd799439011'), true)
   })
 
   it('should return false for a random string', () => {
-    assert.equal(isValid('not-an-objectid'), false)
+    assert.equal(isValidObjectId('not-an-objectid'), false)
   })
 
   it('should return false for an empty string', () => {
-    assert.equal(isValid(''), false)
+    assert.equal(isValidObjectId(''), false)
   })
 
   it('should return false for a number', () => {
-    assert.equal(isValid(12345), false)
+    assert.equal(isValidObjectId(12345), false)
   })
 
   it('should return false for a 23-char hex string', () => {
-    assert.equal(isValid('507f1f77bcf86cd79943901'), false)
+    assert.equal(isValidObjectId('507f1f77bcf86cd79943901'), false)
   })
 
   it('should return false for null', () => {
-    assert.equal(isValid(null), false)
+    assert.equal(isValidObjectId(null), false)
   })
 
   it('should return false for undefined', () => {
-    assert.equal(isValid(undefined), false)
+    assert.equal(isValidObjectId(undefined), false)
   })
 })

package/tests/{utils-parse.spec.js → utils-parseObjectId.spec.js}

@@ -15,24 +15,24 @@ mock.getter(App, 'instance', () => ({
   }
 }))
 
-const { parse } = await import('../lib/utils/parse.js')
+const { parseObjectId } = await import('../lib/utils/parseObjectId.js')
 
-describe('parse()', () => {
+describe('parseObjectId()', () => {
   it('should return same ObjectId if already an ObjectId instance', () => {
     const id = new ObjectId()
-    assert.equal(parse(id), id)
+    assert.equal(parseObjectId(id), id)
   })
 
   it('should convert a valid ObjectId string to an ObjectId', () => {
     const str = '507f1f77bcf86cd799439011'
-    const result = parse(str)
+    const result = parseObjectId(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'),
+      () => parseObjectId('not-a-valid-id'),
       (err) => {
         assert.equal(err.message, 'INVALID_OBJECTID')
         assert.deepEqual(err.data, { value: 'not-a-valid-id' })
@@ -43,7 +43,7 @@ describe('parse()', () => {
 
   it('should throw INVALID_OBJECTID for an empty string', () => {
     assert.throws(
-      () => parse(''),
+      () => parseObjectId(''),
       (err) => {
         assert.equal(err.message, 'INVALID_OBJECTID')
         return true
@@ -53,14 +53,14 @@ describe('parse()', () => {
 
   it('should convert a 24-char hex string', () => {
     const hex = 'aabbccddeeff00112233aabb'
-    const result = parse(hex)
+    const result = parseObjectId(hex)
     assert.ok(result instanceof ObjectId)
     assert.equal(result.toString(), hex)
   })
 
   it('should throw for a 23-char string', () => {
     assert.throws(
-      () => parse('507f1f77bcf86cd79943901'),
+      () => parseObjectId('507f1f77bcf86cd79943901'),
       (err) => {
         assert.equal(err.message, 'INVALID_OBJECTID')
         return true

package/lib/ObjectIdUtils.js

@@ -1,37 +0,0 @@
-import { App } from 'adapt-authoring-core'
-import { isValid } from './utils/isValid.js'
-import { parse } from './utils/parse.js'
-
-/**
- * JSON schema integration for MongoDB ObjectIds
- * @memberof mongodb
- */
-class ObjectIdUtils {
-  /**
-   * Registers the isObjectId JSON schema keyword
-   */
-  static async addSchemaKeyword () {
-    const jsonschema = await App.instance.waitForModule('jsonschema')
-    jsonschema.addKeyword({
-      keyword: 'isObjectId',
-      type: 'string',
-      modifying: true,
-      schemaType: 'boolean',
-      compile: () => {
-        return (value, { parentData, parentDataProperty }) => {
-          if (!isValid(value)) {
-            return false
-          }
-          try {
-            parentData[parentDataProperty] = parse(value)
-          } catch (e) {
-            return false
-          }
-          return true
-        }
-      }
-    })
-  }
-}
-
-export default ObjectIdUtils