adapt-authoring-config 0.0.1

package/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/.eslintrc

@@ -0,0 +1,14 @@
+{
+  "env": {
+      "browser": false,
+      "node": true,
+      "commonjs": false,
+      "es2020": true
+  },
+  "extends": [
+      "standard"
+  ],
+  "parserOptions": {
+      "ecmaVersion": 2020
+  }
+}

package/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,55 @@
+name: Bug Report
+description: File a bug report
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: description
+    attributes:
+      label: What happened?
+      description: Please describe the issue
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behaviour
+      description: Tell us what should have happened
+  - type: textarea
+    id: repro-steps
+    attributes:
+      label: Steps to reproduce
+      description: Tell us how to reproduce the issue
+    validations:
+      required: true
+  - type: input
+    id: aat-version
+    attributes:
+      label: Authoring tool version
+      description: What version of the Adapt authoring tool are you running?
+    validations:
+      required: true
+  - type: input
+    id: fw-version
+    attributes:
+      label: Framework version
+      description: What version of the Adapt framework are you running?
+  - type: dropdown
+    id: browsers
+    attributes:
+      label: What browsers are you seeing the problem on?
+      multiple: true
+      options:
+        - Firefox
+        - Chrome
+        - Safari
+        - Microsoft Edge
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: sh

package/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

package/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,22 @@
+name: Feature request
+description: Request a new feature
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to request a new feature in the Adapt authoring tool! The Adapt team will consider all new feature requests, but unfortunately cannot commit to every one.
+  - type: textarea
+    id: description
+    attributes:
+      label: Feature description
+      description: Please describe your feature request
+    validations:
+      required: true
+  - type: checkboxes
+    id: contribute
+    attributes:
+      label: Can you work on this feature?
+      description: If you are able to commit your own time to work on this feature, it will greatly increase the liklihood of it being implemented by the core dev team. Otherwise, it will be triaged and prioritised alongside the core team's current priorities.
+      options:
+        - label: I can contribute

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/.github/pull_request_template.md

@@ -0,0 +1,25 @@
+[//]: # (Please title your PR according to eslint commit conventions)
+[//]: # (See https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-eslint#eslint-convention for details)
+
+[//]: # (Add a link to the original issue)
+
+[//]: # (Delete as appropriate)
+### Fix
+* A sentence describing each fix
+
+### Update
+* A sentence describing each udpate
+
+### New
+* A sentence describing each new feature
+
+### Breaking
+* A sentence describing each breaking change
+
+[//]: # (List appropriate steps for testing if needed)
+### Testing
+1. Steps for testing
+
+[//]: # (Mention any other dependencies)
+
+

package/.github/workflows/labelled_prs.yml

@@ -0,0 +1,16 @@
+name: Add labelled PRs to project
+
+on:
+  pull_request:
+    types: [ labeled ]
+
+jobs:
+  add-to-project:
+    if: ${{ github.event.label.name == 'dependencies' }}
+    name: Add to main project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/add-to-project@v0.1.0
+        with:
+          project-url: https://github.com/orgs/adapt-security/projects/5
+          github-token: ${{ secrets.PROJECTS_SECRET }}

package/.github/workflows/new.yml

@@ -0,0 +1,19 @@
+name: Add to main project
+
+on:
+  issues:
+    types:
+      - opened
+  pull_request:
+    types:
+      - opened
+
+jobs:
+  add-to-project:
+    name: Add to main project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/add-to-project@v0.1.0
+        with:
+          project-url: https://github.com/orgs/adapt-security/projects/5
+          github-token: ${{ secrets.PROJECTS_SECRET }}

package/README.md

@@ -0,0 +1 @@
+adapt-authoring-config

package/adapt-authoring.json

@@ -0,0 +1,12 @@
+{
+  "essentialType": "config",
+  "documentation": {
+    "enable": true,
+    "manualPlugins": ["docs/plugins/configuration.js"],
+    "manualPages": {
+      "configuration.md": "reference",
+      "configure-environment.md": "getting-started",
+      "defining-config.md": "basics"
+    }
+  }
+}

package/artillery.yml

@@ -0,0 +1,4 @@
+scenarios:
+  - flow:
+    - get:
+        url: "/config"

package/bin/confgen.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Generates a template config file which can be populated with required values.
+ * @param {String} [environment] The enviroment to write the config for
+ * @param {String} --defaults Will include default values
+ * @param {String} --replace Will override any existing values
+ * @param {String} --update Will update existing configuration with any missing values
+ */
+import fs from 'fs/promises'
+import { globSync } from 'glob'
+import path from 'path'
+import { pathToFileURL } from 'url'
+import { Utils } from 'adapt-authoring-core'
+
+const {
+  defaults: useDefaults,
+  params: [env],
+  replace: replaceExisting,
+  update: updateExisting
+} = Utils.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`)
+const configJson = {}
+
+async function init () {
+  if (!NODE_ENV) {
+    return console.log('ERROR: NODE_ENV must be specified\n')
+  }
+  if (replaceExisting && updateExisting) {
+    return console.log('ERROR: --update and --replace cannot both be specified, please choose one and run the utility again')
+  }
+  if (useDefaults) {
+    console.log('Default values will be included')
+  }
+  let isExistingConfig = false
+  let existingConfig
+  try {
+    existingConfig = (await import(pathToFileURL(outpath))).default
+    isExistingConfig = true
+  } catch (e) {
+    console.log(`No config found for NODE_ENV '${NODE_ENV}'. File will be written to ${outpath}\n`)
+  }
+  if (isExistingConfig) {
+    const msg = `Config already exists for NODE_ENV '${NODE_ENV}'. `
+    if (replaceExisting) {
+      console.log(`${msg}All existing values will be replaced.`)
+    } else if (updateExisting) {
+      console.log(`${msg}Any missing values will be added.`)
+      Object.assign(configJson, existingConfig)
+    } else {
+      return console.log(`${msg}Must specifiy --replace or --update to make changes.`)
+    }
+  }
+  try {
+    await generateConfig()
+    try {
+      await fs.mkdir(confDir, { recursive: true })
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e
+    }
+    await fs.writeFile(outpath, `export default ${JSON.stringify(configJson, null, 2)};`)
+
+    console.log(`Config file written successfully to ${outpath}.\n`)
+
+    logRequired()
+  } catch (e) {
+    console.log(`ERROR: Failed to write ${outpath}\n${e}`)
+  }
+}
+
+function logRequired () {
+  const requiredAttrs = []
+  Object.entries(configJson).forEach(([name, config]) => {
+    Object.entries(config).forEach(([key, value]) => value === null && requiredAttrs.push(`${name}.${key}`))
+  })
+  if (requiredAttrs.length) {
+    console.log('Note: the following required attributes have been given a value of null and must be set for the application to run:\n')
+    console.log(requiredAttrs.join('\n'))
+    console.log('')
+  }
+}
+
+async function getDeps () {
+  try {
+    const depRoot = `${process.cwd()}/node_modules/`.replaceAll(path.sep, path.posix.sep)
+    return globSync(`${depRoot}**/adapt-authoring.json`).map(f => {
+      const dirname = path.dirname(f)
+      return [dirname.replace(depRoot, ''), dirname]
+    })
+  } catch (e) {
+    console.log('Failed to load package', e)
+  }
+}
+
+async function generateConfig () {
+  await Promise.all((await getDeps()).map(async ([name, dir]) => {
+    let schema
+    try {
+      schema = schema = JSON.parse(await fs.readFile(path.resolve(dir, 'conf/config.schema.json')))
+    } catch (e) {
+      return
+    }
+    if (!configJson[name]) {
+      configJson[name] = {}
+    }
+    storeDefaults(schema, configJson[name])
+    // remove any empty objects
+    Object.entries(configJson).forEach(([key, config]) => !Object.keys(config).length && delete configJson[key])
+  }))
+}
+function storeDefaults (schema, defaults = {}) {
+  return Object.entries(schema.properties).reduce((memo, [attr, config]) => {
+    if (config.type === 'object' && config.properties) {
+      return { ...memo, [attr]: storeDefaults(config, memo) }
+    }
+    config.required = schema?.required?.includes(attr) ?? false
+    const shouldUpdate = replaceExisting || !Object.prototype.hasOwnProperty.call(memo, attr)
+    const useDefault = useDefaults && Object.prototype.hasOwnProperty.call(config, 'default')
+    if (shouldUpdate && (useDefault || config.required)) {
+      memo[attr] = getValueForAttr(config)
+    }
+    return memo
+  }, defaults)
+}
+
+function getValueForAttr (config) {
+  if (config.required) return null
+  if (Object.prototype.hasOwnProperty.call(config, 'default')) return config.default
+}
+
+init()

package/docs/configure-environment.md

@@ -0,0 +1,53 @@
+# Configuring your environment
+> For a list of all supported configuration options, see [this page](configuration).
+
+The authoring tool has been built to allow for multiple configurations for different system environments (e.g. testing, production, development).
+
+## Set up your environment
+
+To configure your tool for a specific environment, you must create a config file in `/conf` named according to the env value your system will be using (e.g. `dev.config.js`, `production.config.js`, `helloworld.config.js`). We recommend sticking to something short like `dev`, or `test`, but it's up to you what you name these; just make sure to set the environment variable to the same.
+
+> The `NODE_ENV` environment variable is used to determine the current environment, so make sure that this is set appropriately when running the application:
+
+Express.js has a number of [performance enhancing features](https://expressjs.com/en/advanced/best-practice-performance.html#set-node_env-to-production) which are only enabled when the NODE_ENV is set to `production`, so we strongly recommend you use this for your production env name.
+
+### Creating your config
+
+Each config file is a JavaScript file which exports a single object. Within this file, settings are grouped by module:
+
+```Javascript
+export default {
+  'modulename': {
+    // settings
+  }
+};
+```
+
+See [this page](configuration) for a complete list of all configuration options.
+
+#### 
+For convenience, we've bundled a script which will generate a new config file for you automatically. 
+
+You can do this by running the following:
+```bash
+npx at-confgen [NODE_ENV]
+```
+
+> If you choose to include the default settings in your configuration, please be aware that once set, these values will not be updated if the defaults change in the future. It is advised therefore that you leave out any settings that you don't wish to change.
+
+See the [Bin scripts](binscripts#at-confgen) page for more information, included supported flags.
+
+### Setting your 'env'
+
+You can do this temporarily using the following:
+
+**Bash/Mac OS Terminal**:
+```bash
+$ NODE_ENV=dev npm start
+```
+**Windows Powershell/Command Prompt**:
+```bash
+> set NODE_ENV=dev | npm start
+```
+
+Please see the documentation for your own operating system for instructions on how to save environment variables in a more permanent way.

package/docs/defining-config.md

@@ -0,0 +1,63 @@
+# Defining module configuration
+
+As a module developer, you will likely have a number of user-configurable attributes for adjusting the functionality of your module. This is great from a user perspective as it allows customisation, but can introduce various bugs as a result of bad user input (missing or unexpected values etc.)
+
+The Adapt authoring tool's configuration module aims to pre-empt as many of these issues as possible through the use of configuration **schemas**, which can define the following:
+- Required attributes
+- Default values for optional attributes
+- Expected type for values (e.g. number, string, array)
+- Validation constraints (see JSON schema spec)
+
+## Defining module configuration
+_**Note**: it is not mandatory to include a config schema for your module, but it may help your general wellbeing/code neatness..._
+
+All that's needed to enable this feature is to include a `config.schema.json` to a directory named `conf` in the root of your module.
+
+This file must export a valid JSON object. See the JSON schema docs for more information.
+
+### Example configuration schema
+The below example shows a few common configuration use-cases:
+
+```json
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "requiredAttribute": {
+      "type": "Number",
+      "description": "This option is required"
+    },
+    "optionalAttribute": {
+      "type": "String",
+      "default": "This will be the default value",
+      "description": "An optional attribute with a default value"
+    },
+  },
+  "required": ["requiredAttribute"]
+}
+```
+
+## Directory paths
+
+It may be necessary to define directory paths in your config schema (e.g. the assets module defines an `uploadDir` attribute). To make this simpler from a developer _and_ user perspective, you can make use of the special `isDirectory` JSON schema keyword which will automatically populate the value with a number of global directory paths.
+
+If `isDirectory` is set in a config schema, the configuration module will look for the following keys and replace them with the corresponding `adapt-authoring-core` config values:
+
+- `$ROOT` -> `adapt-authoring-core.rootDir`
+- `$DATA` -> `adapt-authoring-core.dataDir`
+- `$TEMP` -> `adapt-authoring-core.tempDir`
+
+This allows the user to specify just the `dataDir` and `tempDir` attributes, and you can be safe in the knowledge that your config schema value will resolve to the correct location.
+
+See the following JSON schema snippet as an example:
+
+```json
+{
+  "uploadDir": {
+    "type": "String",
+    "description": "Temporary file upload directory for myplugin",
+    "isDirectory": true,
+    "default": "$TEMP/myfiles"
+  },
+}
+```

package/docs/plugins/configuration.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+
+export default class Configuration {
+  async run() {
+    const schemas = this.loadSchemas();
+    this.contents = Object.keys(schemas).sort();
+    this.manualFile = 'configuration.md';
+    this.replace = {
+      'CODE_EXAMPLE': this.generateCodeExample(schemas),
+      'LIST': this.generateList(schemas)
+    };
+  }
+  loadSchemas() {
+    const schemas = {};
+    Object.values(this.app.dependencies).forEach(c => {
+      const confDir = path.join(c.rootDir, 'conf');
+      try {
+        schemas[c.name] = JSON.parse(fs.readFileSync(path.join(confDir, 'config.schema.json')));
+      } catch(e) {}
+    });
+    return schemas;
+  }
+  generateCodeExample(schemas) {
+    let output = '\`\`\`javascript\nexport default {\n';
+    this.contents.forEach((name) => {
+      const schema = schemas[name];
+      output += `  '${name}': {\n`;
+      Object.entries(schema.properties).forEach(([attr, config]) => {
+        const required = schema.required && schema.required.includes(attr);
+        if(config.description) output += `    // ${config.description}\n`;
+        output += `    ${attr}: ${this.defaultToMd(config)}, // ${config.type}, ${required ? 'required' : 'optional'}\n`;
+      });
+      output += `  },\n`;
+    });
+    output += `};\n\`\`\``;
+    return output;
+  }
+  generateList(schemas) {
+    let output = '';
+
+    this.contents.forEach(dep => {
+      const schema = schemas[dep];
+      output += `<h3 id="${dep}" class="dep">${dep}</h3>\n\n`;
+      output += `<div class="options">\n`;
+      Object.entries(schema.properties).forEach(([attr, config]) => {
+        const required = schema.required && schema.required.includes(attr);
+        output += `<div class="attribute">\n`;
+        output += `<div class="title"><span class="main">${attr}</span> (${config.type || ''}, ${required ? 'required' : 'optional'})</div>\n`;
+        output += `<div class="inner">\n`;
+        output += `<div class="description">${config.description}</div>\n`;
+        if(!required) {
+          output += `<div class="default"><span class="label">Default</span>: <pre>${this.defaultToMd(config)}</pre></div>\n`;
+        }
+        output += `</div>\n`;
+        output += `</div>\n`;
+      });
+      output += `</div>`;
+      output += `\n\n`;
+    });
+
+    return output;
+  }
+  /**
+   * Returns a string formatted nicely for markdown
+   */
+  defaultToMd(config) {
+    return JSON.stringify(config.default);
+  }
+}

package/docs/plugins/configuration.md

@@ -0,0 +1,14 @@
+# Configuration reference
+This page lists all configuration options supported by the [core bundle](coremodules) of Adapt authoring modules.
+
+{{{TABLE_OF_CONTENTS}}}
+
+## Quick reference
+See below for an overview of all available configuration options.
+
+{{{CODE_EXAMPLE}}}
+
+## Complete reference
+See below for a full list of available configuration options.
+
+{{{LIST}}}

package/errors/errors.json

@@ -0,0 +1,14 @@
+{
+  "FILE_SYNTAX_ERROR": {
+    "data": {
+      "path": "Path to the invalid file",
+      "message": "The error message"
+    },
+    "description": "File contains a syntax error",
+    "statusCode": 500
+  },
+  "LOAD_ERROR": {
+    "description": "Config failed to load",
+    "statusCode": 500
+  }
+}

package/index.js

@@ -0,0 +1,5 @@
+/**
+ * Application configuration storage
+ * @namespace config
+ */
+export { default } from './lib/ConfigModule.js'

package/lib/ConfigModule.js

@@ -0,0 +1,236 @@
+/* eslint no-console: 0 */
+import { AbstractModule } from 'adapt-authoring-core'
+import chalk from 'chalk'
+import path from 'path'
+import { pathToFileURL } from 'url'
+/**
+ * Module to expose config API
+ * @memberof config
+ * @extends {AbstractModule}
+ */
+class ConfigModule extends AbstractModule {
+  /** @override */
+  async init () {
+    // set references to module on main App instance
+    this.app.config = this
+
+    /** @ignore */
+    this._config = {}
+    /**
+     * Path to the user configuration file
+     * @type {String}
+     */
+    this.configFilePath = path.join(this.app.rootDir, 'conf', `${process.env.NODE_ENV}.config.js`)
+    /**
+     * The keys for all attributes which can be modified during runtime
+     * @type {Array<String>}
+     */
+    this.mutableAttributes = []
+    /**
+     * The keys for all attributes marked as public
+     * @type {Array<String>}
+     */
+    this.publicAttributes = []
+
+    try {
+      // need to wait for errors to ensure correct logging
+      await this.app.waitForModule('errors')
+
+      await this.storeUserSettings()
+      await this.storeEnvSettings()
+      await this.storeSchemaSettings()
+
+      this.log('info', `using config at ${this.configFilePath}`)
+    } catch (e) {
+      console.log(e)
+      console.log(`\n${chalk.red(`Config failed to initialise for environment '${process.env.NODE_ENV}'. See above for details.`)}\n`)
+      throw this.app.errors.LOAD_ERROR
+    }
+    /*
+    * Note: we wait until after the ready signal before initialising router because ConfigModule needs to be
+    * available straight away (and not wait for server etc.)
+    */
+    this.onReady().then(() => this.initRouter())
+  }
+
+  /**
+   * Adds routing functionality
+   * @return {Promise}
+   */
+  async initRouter () {
+    const [auth, server] = await this.app.waitForModule('auth', 'server')
+    const router = server.api.createChildRouter('config')
+    router.addRoute({
+      route: '/',
+      handlers: { get: (req, res) => res.json(this.getPublicConfig(req.params.mutable)) },
+      meta: {
+        get: {
+          summary: 'Retrieve public config data',
+          responses: {
+            200: {
+              description: 'The public config item data',
+              content: { 'application/json': { schema: { type: 'object' } } }
+            }
+          }
+        }
+      }
+    })
+    auth.unsecureRoute(router.path, 'get')
+  }
+
+  /**
+   * Copy env values to config
+   * @return {Promise}
+   */
+  async storeEnvSettings () {
+    Object.entries(process.env).forEach(([key, val]) => {
+      try { // try to parse to allow for non-string values
+        val = JSON.parse(val)
+      } catch {} // ignore errors
+      this.set(this.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}
+   */
+  async storeUserSettings () {
+    let c
+    try {
+      c = (await import(pathToFileURL(this.configFilePath))).default
+    } catch (e) {
+      if (e.code !== 'ENOENT' && e.code !== 'ERR_MODULE_NOT_FOUND') {
+        console.trace(e)
+        throw e
+      }
+    }
+    if (!c) {
+      console.log(chalk.yellow(`No config file found at '${this.configFilePath}', attempting to run with defaults\n`))
+      return
+    }
+    Object.entries(c).forEach(([name, config]) => {
+      Object.entries(config).forEach(([key, val]) => {
+        this.set(`${name}.${key}`, val)
+      })
+    })
+  }
+
+  /**
+   * Processes all module config schema files
+   * @return {Promise}
+   */
+  async storeSchemaSettings () {
+    const jsonschema = await this.app.waitForModule('jsonschema')
+    const deps = Object.values(this.app.dependencies)
+    // run core first as other modules may use its config values
+    await this.processModuleSchema(deps.find(d => d.name === this.app.name), jsonschema)
+    const promises = deps.map(d => this.processModuleSchema(d, jsonschema))
+    let hasErrored = false;
+
+    (await Promise.allSettled(promises)).forEach(r => {
+      if (r.status === 'rejected') {
+        hasErrored = true
+        if (r.reason?.data?.errors) {
+          console.log(`${r.reason.modName}: ${r.reason.data.errors}`)
+        } else {
+          console.log(r.reason)
+        }
+      }
+    })
+    if (hasErrored) throw new Error()
+  }
+
+  /**
+   * Processes and validates a single module config schema (checks the user config specifies any required fields, and that they are the expected type)
+   * @param {Object} pkg Package.json data
+   * @param {JsonSchemaModule} jsonschema Module instance for validation
+   * @return {Promise}
+   */
+  async processModuleSchema (pkg, jsonschema) {
+    if (!pkg.name || !pkg.rootDir) return
+
+    const schemaPath = path.resolve(pkg.rootDir, 'conf/config.schema.json')
+    let schema
+    try {
+      schema = await (await jsonschema.createSchema(schemaPath)).build()
+    } catch (e) {
+      return
+    }
+    // validate user config data
+    let data = Object.entries(schema.raw.properties).reduce((m, [k, v]) => {
+      if (v?._adapt?.isMutable) this.mutableAttributes.push(`${pkg.name}.${k}`)
+      if (v?._adapt?.isPublic) this.publicAttributes.push(`${pkg.name}.${k}`)
+      return { ...m, [k]: this.get(`${pkg.name}.${k}`) }
+    }, {})
+    try {
+      data = await schema.validate(data)
+    } catch (e) {
+      e.modName = pkg.name
+      throw e
+    }
+    // apply validated config settings
+    Object.entries(data).forEach(([key, val]) => this.set(`${pkg.name}.${key}`, val, { force: true }))
+  }
+
+  /**
+   * Determines whether an attribute has a set value
+   * @param {String} attr Attribute key name
+   * @return {Boolean} Whether the value exists
+   */
+  has (attr) {
+    return Object.hasOwn(this._config, attr)
+  }
+
+  /**
+   * Returns a value for a given attribute
+   * @param {String} attr Attribute key name
+   * @return {*} The attribute's value
+   */
+  get (attr) {
+    return this._config[attr]
+  }
+
+  /**
+   * Stores a value for the passed attribute
+   * @param {String} attr Attribute key name
+   * @param {*} val Value to set
+   * @param {objeect} options Custom options
+   * @param {objeect} options.force Whether to force an update
+   */
+  set (attr, val, options = {}) {
+    if (this.has(attr) && !this.mutableAttributes.includes(attr) && options.force !== true) {
+      return
+    }
+    this._config[attr] = val
+  }
+
+  /**
+   * Retrieves all config options marked as 'public'
+   * @param {Boolean} isMutable Whether options should also be mutable
+   * @return {Object}
+   */
+  getPublicConfig (isMutable) {
+    return this.publicAttributes.reduce((m, a) => {
+      if (!isMutable || (isMutable && this.mutableAttributes.includes(a))) {
+        m[a] = this.get(a)
+      }
+      return m
+    }, {})
+  }
+}
+
+export default ConfigModule

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "adapt-authoring-config",
+  "version": "0.0.1",
+  "description": "A configuration module for the Adapt authoring tool.",
+  "homepage": "https://github.com/adapt-security/adapt-authoring-config",
+  "license": "GPL-3.0",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "at-confgen": "./bin/confgen.js"
+  },
+  "repository": "github:adapt-security/adapt-authoring-config",
+  "dependencies": {
+    "adapt-authoring-core": "github:adapt-security/adapt-authoring-core",
+    "chalk": "^5.3.0",
+    "glob": "^11.0.0"
+  },
+  "peerDependencies": {
+    "adapt-authoring-core": "github:adapt-security/adapt-authoring-core"
+  },
+  "devDependencies": {
+    "eslint": "^9.12.0",
+    "standard": "^17.1.0"
+  }
+}

package/tests/configModule.spec.js

@@ -0,0 +1,61 @@
+const Config = require('../lib/configUtils');
+const path = require('path');
+const should = require('should');
+
+describe('Config module', function() {
+  before(function() {
+    this.config = new Config(global.ADAPT.app, {});
+    this.configJson = require(path.join(process.cwd(), 'conf', 'testing.config.js'));
+  });
+  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('#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();
+    });
+    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();
+    });
+  });
+  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('#set()', function() {
+    it('should be able to set a value', function() {
+      const newValue = 'newtestvalue';
+      this.config.set('adapt-authoring-testing.test', newValue);
+      const actualValue = this.config.get('adapt-authoring-testing.test');
+      actualValue.should.equal(newValue);
+    });
+  });
+  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');
+    });
+  });
+});
+/**
+* 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/configUtils.spec.js

@@ -0,0 +1,34 @@
+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();
+      });
+    });
+  });
+});

package/tests/data/conf/config.schema.js

@@ -0,0 +1,10 @@
+module.exports = {
+  definition: {
+    one: {
+      type: 'String',
+      default: 'default',
+      description: 'Test option',
+      public: true
+    }
+  }
+};

package/tests/data/incorrecttype/conf/config.schema.js

@@ -0,0 +1,7 @@
+module.exports = {
+  definition: {
+    typecheck: {
+      type: 'Number'
+    }
+  }
+};

package/tests/data/invalid/conf/config.schema.js

@@ -0,0 +1,8 @@
+module.exports = {
+  definition: {
+    validator: {
+      type: 'Number',
+      validator: val => val === 4
+    }
+  }
+};

package/tests/data/required/conf/config.schema.js

@@ -0,0 +1,8 @@
+module.exports = {
+  definition: {
+    required: {
+      type: 'Number',
+      required: true
+    }
+  }
+};

package/tests/data/testfile.json

@@ -0,0 +1,3 @@
+{
+  "test": true
+}