adapt-authoring-api 1.4.0 → 1.6.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/lib/AbstractApiModule.js

@@ -497,8 +497,8 @@ class AbstractApiModule extends AbstractModule {
    * @param {Object} mongoOpts The MongoDB options
    */
   async setUpPagination (req, res, mongoOpts) {
-    const maxPageSize = this.app.config.get('adapt-authoring-api.maxPageSize')
-    let pageSize = mongoOpts.limit ?? this.app.config.get('adapt-authoring-api.defaultPageSize')
+    const maxPageSize = this.getConfig('maxPageSize') ?? this.app.config.get('adapt-authoring-api.maxPageSize')
+    let pageSize = mongoOpts.limit ?? this.getConfig('defaultPageSize') ?? this.app.config.get('adapt-authoring-api.defaultPageSize')
 
     if (pageSize > maxPageSize) pageSize = maxPageSize
 

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "adapt-authoring-api",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Abstract module for creating APIs",
   "homepage": "https://github.com/adapt-security/adapt-authoring-api",
   "license": "GPL-3.0",
   "type": "module",
   "main": "index.js",
   "repository": "github:adapt-security/adapt-authoring-api",
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
+  },
   "dependencies": {
     "adapt-authoring-core": "^1.7.0",
     "lodash": "^4.17.21"

package/tests/AbstractApiModule.spec.js

@@ -0,0 +1,59 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import AbstractApiModule from '../lib/AbstractApiModule.js'
+
+describe('AbstractApiModule', () => {
+  describe('#mapStatusCode()', () => {
+    const instance = Object.create(AbstractApiModule.prototype)
+
+    const cases = [
+      { method: 'post', expected: 201 },
+      { method: 'get', expected: 200 },
+      { method: 'put', expected: 200 },
+      { method: 'patch', expected: 200 },
+      { method: 'delete', expected: 204 }
+    ]
+    cases.forEach(({ method, expected }) => {
+      it(`should return ${expected} for ${method.toUpperCase()}`, () => {
+        assert.equal(instance.mapStatusCode(method), expected)
+      })
+    })
+
+    it('should return undefined for unknown methods', () => {
+      assert.equal(instance.mapStatusCode('options'), undefined)
+    })
+  })
+
+  describe('#setDefaultOptions()', () => {
+    it('should populate defaults on an empty options object', () => {
+      const instance = Object.create(AbstractApiModule.prototype)
+      instance.schemaName = 'testSchema'
+      instance.collectionName = 'testCollection'
+      const options = {}
+      instance.setDefaultOptions(options)
+      assert.equal(options.schemaName, 'testSchema')
+      assert.equal(options.collectionName, 'testCollection')
+      assert.equal(options.validate, true)
+      assert.equal(options.invokePreHook, true)
+      assert.equal(options.invokePostHook, true)
+    })
+
+    it('should not override existing values', () => {
+      const instance = Object.create(AbstractApiModule.prototype)
+      instance.schemaName = 'testSchema'
+      instance.collectionName = 'testCollection'
+      const options = { schemaName: 'customSchema', validate: false }
+      instance.setDefaultOptions(options)
+      assert.equal(options.schemaName, 'customSchema')
+      assert.equal(options.validate, false)
+    })
+
+    it('should handle undefined options by creating defaults', () => {
+      const instance = Object.create(AbstractApiModule.prototype)
+      instance.schemaName = 'testSchema'
+      instance.collectionName = 'testCollection'
+      const options = instance.setDefaultOptions()
+      assert.equal(options, undefined)
+    })
+  })
+})

package/tests/AbstractApiUtils.spec.js

@@ -0,0 +1,139 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import AbstractApiUtils from '../lib/AbstractApiUtils.js'
+
+describe('AbstractApiUtils', () => {
+  describe('.httpMethodToAction()', () => {
+    it('should return "read" for GET', () => {
+      assert.equal(AbstractApiUtils.httpMethodToAction('get'), 'read')
+      assert.equal(AbstractApiUtils.httpMethodToAction('GET'), 'read')
+    })
+
+    const writeMethods = ['post', 'put', 'patch', 'delete']
+    writeMethods.forEach(method => {
+      it(`should return "write" for ${method.toUpperCase()}`, () => {
+        assert.equal(AbstractApiUtils.httpMethodToAction(method), 'write')
+        assert.equal(AbstractApiUtils.httpMethodToAction(method.toUpperCase()), 'write')
+      })
+    })
+
+    it('should return empty string for unknown methods', () => {
+      assert.equal(AbstractApiUtils.httpMethodToAction('options'), '')
+      assert.equal(AbstractApiUtils.httpMethodToAction('head'), '')
+    })
+  })
+
+  describe('.httpMethodToDBFunction()', () => {
+    const cases = [
+      { method: 'post', expected: 'insert' },
+      { method: 'get', expected: 'find' },
+      { method: 'put', expected: 'update' },
+      { method: 'patch', expected: 'update' },
+      { method: 'delete', expected: 'delete' }
+    ]
+    cases.forEach(({ method, expected }) => {
+      it(`should return "${expected}" for ${method.toUpperCase()}`, () => {
+        assert.equal(AbstractApiUtils.httpMethodToDBFunction(method), expected)
+      })
+    })
+
+    it('should be case-insensitive', () => {
+      assert.equal(AbstractApiUtils.httpMethodToDBFunction('POST'), 'insert')
+      assert.equal(AbstractApiUtils.httpMethodToDBFunction('Get'), 'find')
+    })
+
+    it('should return empty string for unknown methods', () => {
+      assert.equal(AbstractApiUtils.httpMethodToDBFunction('options'), '')
+    })
+  })
+
+  describe('.argsFromReq()', () => {
+    const baseApiData = {
+      query: { _id: '123' },
+      data: { name: 'test' },
+      schemaName: 'testSchema',
+      collectionName: 'testCollection'
+    }
+
+    it('should return [query, opts] for GET', () => {
+      const req = { method: 'GET', apiData: baseApiData }
+      const result = AbstractApiUtils.argsFromReq(req)
+      assert.deepEqual(result[0], baseApiData.query)
+      assert.deepEqual(result[1], { schemaName: 'testSchema', collectionName: 'testCollection' })
+      assert.equal(result.length, 2)
+    })
+
+    it('should return [query, opts] for DELETE', () => {
+      const req = { method: 'DELETE', apiData: baseApiData }
+      const result = AbstractApiUtils.argsFromReq(req)
+      assert.deepEqual(result[0], baseApiData.query)
+      assert.equal(result.length, 2)
+    })
+
+    it('should return [data, opts] for POST', () => {
+      const req = { method: 'POST', apiData: baseApiData }
+      const result = AbstractApiUtils.argsFromReq(req)
+      assert.deepEqual(result[0], baseApiData.data)
+      assert.equal(result.length, 2)
+    })
+
+    it('should return [query, data, opts] for PUT', () => {
+      const req = { method: 'PUT', apiData: baseApiData }
+      const result = AbstractApiUtils.argsFromReq(req)
+      assert.deepEqual(result[0], baseApiData.query)
+      assert.deepEqual(result[1], baseApiData.data)
+      assert.equal(result.length, 3)
+    })
+
+    it('should return [query, data, opts] for PATCH', () => {
+      const req = { method: 'PATCH', apiData: baseApiData }
+      const result = AbstractApiUtils.argsFromReq(req)
+      assert.deepEqual(result[0], baseApiData.query)
+      assert.deepEqual(result[1], baseApiData.data)
+      assert.equal(result.length, 3)
+    })
+
+    it('should return undefined for unknown methods', () => {
+      const req = { method: 'OPTIONS', apiData: baseApiData }
+      assert.equal(AbstractApiUtils.argsFromReq(req), undefined)
+    })
+  })
+
+  describe('.stringifyValues()', () => {
+    it('should pass through plain values unchanged', () => {
+      const data = { a: 'hello', b: 42, c: true, d: null }
+      const result = AbstractApiUtils.stringifyValues(data)
+      assert.deepEqual(result, data)
+    })
+
+    it('should convert Date values to strings', () => {
+      const date = new Date('2025-01-01T00:00:00.000Z')
+      const result = AbstractApiUtils.stringifyValues({ date })
+      assert.equal(typeof result.date, 'string')
+      assert.equal(result.date, date.toString())
+    })
+
+    it('should recursively process nested objects', () => {
+      const data = { nested: { value: 'test', date: new Date('2025-01-01') } }
+      const result = AbstractApiUtils.stringifyValues(data)
+      assert.equal(typeof result.nested, 'object')
+      assert.equal(typeof result.nested.date, 'string')
+    })
+
+    it('should recursively process arrays', () => {
+      const date = new Date('2025-01-01')
+      const data = { items: [date, 'text', 42] }
+      const result = AbstractApiUtils.stringifyValues(data)
+      assert.ok(Array.isArray(result.items))
+      assert.equal(typeof result.items[0], 'string')
+      assert.equal(result.items[1], 'text')
+      assert.equal(result.items[2], 42)
+    })
+
+    it('should return an array when input is an array', () => {
+      const result = AbstractApiUtils.stringifyValues([{ a: 1 }, { b: 2 }])
+      assert.ok(Array.isArray(result))
+      assert.equal(result.length, 2)
+    })
+  })
+})

package/tests/DataCache.spec.js

@@ -0,0 +1,47 @@
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert/strict'
+
+describe('DataCache', () => {
+  let DataCache
+
+  before(async () => {
+    // DataCache constructor references App.instance.config, so we need to
+    // dynamically import after ensuring no app instance is required for prune tests.
+    // We import the module directly and test what we can without the full app.
+    DataCache = (await import('../lib/DataCache.js')).default
+  })
+
+  describe('#prune()', () => {
+    it('should remove expired entries from the cache', () => {
+      const instance = Object.create(DataCache.prototype)
+      instance.lifespan = 100
+      instance.cache = {
+        expired: { data: [1], timestamp: Date.now() - 200 },
+        valid: { data: [2], timestamp: Date.now() }
+      }
+      instance.prune()
+      assert.equal(instance.cache.expired, undefined)
+      assert.ok(instance.cache.valid)
+    })
+
+    it('should keep entries that have not expired', () => {
+      const instance = Object.create(DataCache.prototype)
+      instance.lifespan = 10000
+      instance.cache = {
+        a: { data: [1], timestamp: Date.now() },
+        b: { data: [2], timestamp: Date.now() }
+      }
+      instance.prune()
+      assert.ok(instance.cache.a)
+      assert.ok(instance.cache.b)
+    })
+
+    it('should handle an empty cache', () => {
+      const instance = Object.create(DataCache.prototype)
+      instance.lifespan = 100
+      instance.cache = {}
+      instance.prune()
+      assert.deepEqual(instance.cache, {})
+    })
+  })
+})