adapt-authoring-core 2.4.2 → 2.5.0

package/docs/plugins/coremodules.js

@@ -11,7 +11,7 @@ export default class CoreModules {
 
   async getWorkflowBadges (homepage) {
     if (!homepage) return []
-    const workflows = ['tests', 'standardjs', 'releases']
+    const workflows = ['standardjs', 'tests', 'releases']
     const results = await Promise.all(workflows.map(async w => {
       const url = `${homepage}/actions/workflows/${w}.yml`
       const badgeUrl = `${url}/badge.svg`

package/docs/plugins/licensing.js

@@ -124,7 +124,7 @@ export default class Licensing {
 
   async generateMd () {
     let md = '<tr><th>Name</th><th>Version</th><th>License</th><th>Description</th></tr>\n'
-    this.dependencies.forEach(pkg => {
+    this.dependencies.sort((a, b) => a.name.localeCompare(b.name)).forEach(pkg => {
       md += `<tr><td>${pkg.homepage ? `<a href="${pkg.homepage}" target="_blank">${pkg.name}</a>` : pkg.name}</td><td>${pkg.version}</td><td>${pkg.license}</td><td>${pkg.description}</tr>\n`
     })
     return `<details>\n<summary>Module dependency list</summary>\n<table>${md}</table>\n</details>`

package/index.js

@@ -1,5 +1,6 @@
 export { default as AbstractModule } from './lib/AbstractModule.js'
 export { default as App } from './lib/App.js'
+export { default as DataCache } from './lib/DataCache.js'
 export { default as DependencyLoader } from './lib/DependencyLoader.js'
 export { default as Hook } from './lib/Hook.js'
 export { metadataFileName, packageFileName, isObject, getArgs, spawn, readJson, writeJson, toBoolean, ensureDir, escapeRegExp, stringifyValues, loadDependencyFiles } from './lib/Utils.js'

package/lib/DataCache.js

@@ -0,0 +1,49 @@
+import App from './App.js'
+/**
+ * Time-limited data cache
+ * @memberof core
+ */
+class DataCache {
+  /**
+   * @param {Object} options
+   * @param {Boolean} options.enable Whether the cache is enabled
+   * @param {Number} options.lifespan Cache entry lifespan in milliseconds
+   */
+  constructor ({ enable, lifespan }) {
+    this.isEnabled = enable === true
+    this.lifespan = lifespan
+    this.cache = {}
+  }
+
+  /**
+   * Retrieve cached data, or run fresh query if no cache exists or cache is invalid
+   * @param {Object} query
+   * @param {Object} options
+   * @param {Object} mongoOptions
+   * @returns {*} The cached data
+   */
+  async get (query, options, mongoOptions) {
+    const key = JSON.stringify(query) + JSON.stringify(options) + JSON.stringify(mongoOptions)
+    this.prune()
+    if (this.isEnabled && this.cache[key]) {
+      return this.cache[key].data
+    }
+    const mongodb = await App.instance.waitForModule('mongodb')
+    const data = await mongodb.find(options.collectionName, query, mongoOptions)
+    this.cache[key] = { data, timestamp: Date.now() }
+    return data
+  }
+
+  /**
+   * Removes invalid cache data
+   */
+  prune () {
+    Object.keys(this.cache).forEach(k => {
+      if (Date.now() > (this.cache[k].timestamp + this.lifespan)) {
+        delete this.cache[k]
+      }
+    })
+  }
+}
+
+export default DataCache

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-core",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "A bundle of reusable 'core' functionality",
   "homepage": "https://github.com/adapt-security/adapt-authoring-core",
   "license": "GPL-3.0",

package/tests/DataCache.spec.js

@@ -0,0 +1,39 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import DataCache from '../lib/DataCache.js'
+
+describe('DataCache', () => {
+  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, {})
+    })
+  })
+})