adapt-authoring-config 1.2.0 → 1.4.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@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/bin/confgen.js

@@ -10,14 +10,14 @@ import fs from 'fs/promises'
 import { globSync } from 'glob'
 import path from 'path'
 import { pathToFileURL } from 'url'
-import { Utils } from 'adapt-authoring-core'
+import { getArgs } from 'adapt-authoring-core'
 
 const {
   defaults: useDefaults,
   params: [env],
   replace: replaceExisting,
   update: updateExisting
-} = Utils.getArgs()
+} = getArgs()
 const NODE_ENV = env || process.env.NODE_ENV
 const confDir = path.resolve(path.join(process.cwd(), 'conf'))
 const outpath = path.join(confDir, `${NODE_ENV}.config.js`)

package/lib/ConfigModule.js

@@ -1,6 +1,7 @@
 /* eslint no-console: 0 */
 import { AbstractModule } from 'adapt-authoring-core'
 import chalk from 'chalk'
+import { envVarToConfigKey } from './utils.js'
 import fs from 'fs/promises'
 import path from 'path'
 /**
@@ -81,23 +82,10 @@ class ConfigModule extends AbstractModule {
       try { // try to parse to allow for non-string values
         val = JSON.parse(val)
       } catch {} // ignore errors
-      this._config[this.envVarToConfigKey(key)] = val
+      this._config[envVarToConfigKey(key)] = val
     })
   }
 
-  /**
-   * Parses an environment variable key into a format expected by this module
-   * @param {String} envVar
-   * @return {String} The formatted key
-   */
-  envVarToConfigKey (envVar) {
-    if (envVar.startsWith('ADAPT_AUTHORING_')) {
-      const [modPrefix, key] = envVar.split('__')
-      return `${modPrefix.replace(/_/g, '-').toLowerCase()}.${key}`
-    }
-    return `env.${envVar}`
-  }
-
   /**
    * Loads the relevant config file into memory
    * @return {Promise}

package/lib/utils/envVarToConfigKey.js

@@ -0,0 +1,13 @@
+/**
+ * Parses an environment variable key into a format expected by ConfigModule
+ * @param {String} envVar
+ * @return {String} The formatted key
+ * @memberof config
+ */
+export function envVarToConfigKey (envVar) {
+  if (envVar.startsWith('ADAPT_AUTHORING_')) {
+    const [modPrefix, key] = envVar.split('__')
+    return `${modPrefix.replace(/_/g, '-').toLowerCase()}.${key}`
+  }
+  return `env.${envVar}`
+}

package/lib/utils.js

@@ -0,0 +1 @@
+export { envVarToConfigKey } from './utils/envVarToConfigKey.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-config",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "A configuration module for the Adapt authoring tool.",
   "homepage": "https://github.com/adapt-security/adapt-authoring-config",
   "license": "GPL-3.0",
@@ -9,9 +9,12 @@
   "bin": {
     "at-confgen": "./bin/confgen.js"
   },
+  "scripts": {
+    "test": "node --test tests/*.spec.js"
+  },
   "repository": "github:adapt-security/adapt-authoring-config",
   "dependencies": {
-    "adapt-authoring-core": "^1.7.0",
+    "adapt-authoring-core": "^2.0.0",
     "chalk": "^5.3.0",
     "glob": "^13.0.0"
   },

package/tests/configModule.spec.js

@@ -1,55 +1,137 @@
-/* global before describe, it */
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert/strict'
+import ConfigModule from '../lib/ConfigModule.js'
+import { envVarToConfigKey } from '../lib/utils.js'
 
-const Config = require('../lib/configUtils')
-const path = require('path')
-// const should = require('should')
+describe('ConfigModule', () => {
+  let instance
 
-describe('Config module', function () {
-  before(function () {
-    this.config = new Config(global.ADAPT.app, {})
-    this.configJson = require(path.join(process.cwd(), 'conf', 'testing.config.js'))
+  before(async () => {
+    const noopHook = { tap: () => {}, untap: () => {}, invoke: async () => {} }
+    const noopRouter = { path: '/', createChildRouter: () => noopRouter }
+    const mockApp = {
+      config: null,
+      rootDir: '/test',
+      name: 'test-app',
+      dependencies: {},
+      dependencyloader: { moduleLoadedHook: noopHook },
+      waitForModule: async (...names) => {
+        const mocks = {
+          errors: { LOAD_ERROR: new Error('load') },
+          auth: { unsecureRoute: () => {} },
+          server: { api: { createChildRouter: () => noopRouter } },
+          jsonschema: { createSchema: async () => ({ build: async () => ({}) }) }
+        }
+        const results = names.map(n => mocks[n] || {})
+        return results.length === 1 ? results[0] : results
+      },
+      errors: { LOAD_ERROR: new Error('load') }
+    }
+
+    instance = new ConfigModule(mockApp, {})
+
+    // Wait for the async init to settle (it will error in test mode, which is fine)
+    try { await instance.onReady() } catch (e) { /* expected */ }
+
+    // Ensure internal state is initialized for testing
+    if (!instance._config) instance._config = {}
+    if (!instance.publicAttributes) instance.publicAttributes = []
   })
-  describe('#initialise()', function () {
-    it('should error on missing required attribute', runConfigInitialise('required'))
-    it('should error on incorrect attribute type', runConfigInitialise('incorrecttype'))
-    it('should error on validator fail', runConfigInitialise('invalid'))
+
+  describe('envVarToConfigKey()', () => {
+    it('should convert ADAPT_AUTHORING prefixed env vars to config keys', () => {
+      const result = envVarToConfigKey('ADAPT_AUTHORING_SERVER__PORT')
+      assert.equal(result, 'adapt-authoring-server.PORT')
+    })
+
+    it('should convert underscores to hyphens in module prefix', () => {
+      const result = envVarToConfigKey('ADAPT_AUTHORING_MY_MODULE__KEY')
+      assert.equal(result, 'adapt-authoring-my-module.KEY')
+    })
+
+    it('should prefix non-ADAPT_AUTHORING env vars with "env."', () => {
+      const result = envVarToConfigKey('NODE_ENV')
+      assert.equal(result, 'env.NODE_ENV')
+    })
+
+    it('should handle env vars without double underscore', () => {
+      // When no __ separator exists, key will be undefined
+      // This documents the current behavior of the function
+      const result = envVarToConfigKey('ADAPT_AUTHORING_TEST')
+      assert.equal(result, 'adapt-authoring-test.undefined')
+    })
   })
-  describe('#has()', function () {
-    it('should be able to verify a value exists', function () {
-      const exists = this.config.has('adapt-authoring-testing.test')
-      exists.should.be.true()
+
+  describe('#has()', () => {
+    it('should return true for existing config values', () => {
+      instance._config['test.key'] = 'value'
+      const exists = instance.has('test.key')
+      assert.equal(exists, true)
     })
-    it('should be able to verify a value doesn\'t exist', function () {
-      const exists = this.config.has('adapt-authoring-testing.nonono')
-      exists.should.not.be.true()
+
+    it('should return false for non-existent config values', () => {
+      const exists = instance.has('nonexistent.key')
+      assert.equal(exists, false)
     })
   })
-  describe('#get()', function () {
-    it('should be able to retrieve a value', function () {
-      const actualValue = this.config.get('adapt-authoring-testing.test')
-      const expectedValue = this.configJson['adapt-authoring-testing'].test
-      actualValue.should.equal(expectedValue)
+
+  describe('#get()', () => {
+    it('should retrieve a stored value', () => {
+      instance._config['test.value'] = 'expected'
+      const actual = instance.get('test.value')
+      assert.equal(actual, 'expected')
+    })
+
+    it('should return undefined for non-existent keys', () => {
+      const actual = instance.get('does.not.exist')
+      assert.equal(actual, undefined)
+    })
+
+    it('should retrieve different data types', () => {
+      instance._config['test.string'] = 'text'
+      instance._config['test.number'] = 42
+      instance._config['test.boolean'] = true
+      instance._config['test.object'] = { key: 'value' }
+
+      assert.equal(instance.get('test.string'), 'text')
+      assert.equal(instance.get('test.number'), 42)
+      assert.equal(instance.get('test.boolean'), true)
+      assert.deepEqual(instance.get('test.object'), { key: 'value' })
     })
   })
-  describe('#getPublicConfig()', function () {
-    it('should be able to retrieve values marked as public', function () {
-      this.config.app.dependencies = [{ name: 'adapt-authoring-testing', dir: path.join(__dirname, 'data') }]
-      this.config.initialise()
-      const config = this.config.getPublicConfig()
-      const value = config['adapt-authoring-testing.one']
-      config.should.be.an.Object()
-      value.should.equal('default')
+
+  describe('#getPublicConfig()', () => {
+    it('should return only public attributes', () => {
+      instance._config = {
+        'module.public1': 'value1',
+        'module.public2': 'value2',
+        'module.private': 'secret'
+      }
+      instance.publicAttributes = ['module.public1', 'module.public2']
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {
+        'module.public1': 'value1',
+        'module.public2': 'value2'
+      })
+    })
+
+    it('should return empty object when no public attributes exist', () => {
+      instance._config = { 'module.private': 'secret' }
+      instance.publicAttributes = []
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {})
+    })
+
+    it('should handle undefined values for public attributes', () => {
+      instance._config = {}
+      instance.publicAttributes = ['module.missing']
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {
+        'module.missing': undefined
+      })
     })
   })
 })
-/**
-* Checks ConfigUtility#initialise
-* Loads the testing data in tests/data/dirname
-*/
-function runConfigInitialise (dirname) {
-  return function () {
-    this.config.app.dependencies = [{ name: 'adapt-authoring-testing', dir: path.join(__dirname, 'data', dirname) }]
-    this.config.initialise()
-    this.config.errors.length.should.be.exactly(1)
-  }
-}

package/tests/utils-envVarToConfigKey.spec.js

@@ -0,0 +1,40 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { envVarToConfigKey } from '../lib/utils/envVarToConfigKey.js'
+
+describe('envVarToConfigKey()', () => {
+  it('should convert ADAPT_AUTHORING_ prefixed vars to dotted config keys', () => {
+    assert.equal(envVarToConfigKey('ADAPT_AUTHORING_SERVER__port'), 'adapt-authoring-server.port')
+  })
+
+  it('should handle multi-word module names', () => {
+    assert.equal(envVarToConfigKey('ADAPT_AUTHORING_AUTH_LOCAL__saltRounds'), 'adapt-authoring-auth-local.saltRounds')
+  })
+
+  it('should convert underscores to hyphens in module prefix', () => {
+    assert.equal(envVarToConfigKey('ADAPT_AUTHORING_MONGODB__connectionUri'), 'adapt-authoring-mongodb.connectionUri')
+  })
+
+  it('should lowercase the module prefix', () => {
+    const result = envVarToConfigKey('ADAPT_AUTHORING_CONFIG__enableCache')
+    assert.ok(result.startsWith('adapt-authoring-config.'))
+  })
+
+  it('should prefix non-ADAPT_AUTHORING vars with "env."', () => {
+    assert.equal(envVarToConfigKey('NODE_ENV'), 'env.NODE_ENV')
+    assert.equal(envVarToConfigKey('PORT'), 'env.PORT')
+    assert.equal(envVarToConfigKey('HOME'), 'env.HOME')
+  })
+
+  it('should handle vars starting with ADAPT_ but not ADAPT_AUTHORING_', () => {
+    assert.equal(envVarToConfigKey('ADAPT_FOO'), 'env.ADAPT_FOO')
+  })
+
+  it('should handle empty string', () => {
+    assert.equal(envVarToConfigKey(''), 'env.')
+  })
+
+  it('should preserve the key part after __', () => {
+    assert.equal(envVarToConfigKey('ADAPT_AUTHORING_API__defaultPageSize'), 'adapt-authoring-api.defaultPageSize')
+  })
+})

package/tests/configUtils.spec.js

@@ -1,36 +0,0 @@
-/* global describe, it */
-
-const path = require('path')
-const utils = require('../lib/ConfigUtils')
-const should = require('should')
-
-describe('Config utils', function () {
-  describe('#loadFile()', function () {
-    it('should be able to load a valid file', function () {
-      const filepath = path.join(__dirname, 'data', 'testfile.json')
-      const actualContents = utils.loadFile(filepath)
-      const expectedContents = require(filepath)
-      actualContents.should.deepEqual(expectedContents)
-    })
-    it('should not error on a missing file', function () {
-      should.doesNotThrow(function () {
-        const contents = utils.loadFile(path.join('this', 'path', 'does', 'not', 'exist.xyz'))
-        should(contents).be.undefined()
-      })
-    })
-  })
-  describe('#loadConfigSchema()', function () {
-    it('should be able to load a valid schema file', function () {
-      const dir = path.join(__dirname, 'data')
-      const actualContents = utils.loadConfigSchema(dir)
-      const expectedContents = require(path.join(dir, 'conf', 'config.schema.js'))
-      actualContents.should.deepEqual(expectedContents)
-    })
-    it('should not error on a missing schema file', function () {
-      should.doesNotThrow(function () {
-        const contents = utils.loadConfigSchema(path.join(__dirname, 'doesntexist'))
-        should(contents).be.undefined()
-      })
-    })
-  })
-})