adapt-authoring-contentplugin 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/adapt-authoring.json

@@ -0,0 +1,5 @@
+{
+  "documentation": {
+    "enable": true
+  }
+}

package/conf/config.schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "pluginDir": {
+      "description": "Location of locally installed plugins",
+      "type": "string",
+      "isDirectory": true,
+      "default": "$DATA/contentplugins"
+    }
+  }
+}

package/errors/errors.json

@@ -0,0 +1,76 @@
+{
+  "CONTENTPLUGIN_ALREADY_EXISTS": {
+    "data": {
+      "name": "Name of content plugin",
+      "version": "Version of content plugin"
+    },
+    "description": "Plugin already exists with the same name and version",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_ATTR_CLASH": {
+    "data": {
+      "name": "Name of content plugin",
+      "targetAttribute": "Offending target attribute"
+    },
+    "description": "Target attribute already used in another plugin",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_ATTR_MISSING": {
+    "data": {
+      "name": "Name of content plugin"
+    },
+    "description": "Pluginis missing targetAttribute value",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_INCOMPAT_FW": {
+    "data": {
+      "installedFramework": "Version of the framework which is installed",
+      "name": "Name of content plugin",
+      "requiredFramework": "Version of the framework which is required",
+      "version": "Version of content plugin"
+    },
+    "description": "Plugin incompatible with the installed framework version",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_CLI_INSTALL_FAILED": {
+    "data": {
+      "name": "Name of content plugin"
+    },
+    "description": "Installation via adapt-cli failed",
+    "statusCode": 500
+  },
+  "CONTENTPLUGIN_IN_USE": {
+    "data": {
+      "courses": "List of courses using the content plugin"
+    },
+    "description": "Content plugin is in use in existing courses",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_INSTALL_FAILED": {
+    "data": {
+      "errors": "List of errors"
+    },
+    "description": "Installation of plugins failed",
+    "statusCode": 500
+  },
+  "CONTENTPLUGIN_INVALID_ZIP": {
+    "description": "Invalid plugin data provided",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_NEWER_INSTALLED": {
+    "data": {
+      "existingVersion": "Installed version",
+      "name": "Name of content plugin",
+      "newVersion": "Version to install"
+    },
+    "description": "Plugin already exists at a higher version",
+    "statusCode": 400
+  },
+  "CONTENTPLUGIN_VERSION_MISMATCH": {
+    "data": {
+      "registered": "Plugins that do not match their installed version"
+    },
+    "description": "The installed version of a plugin does not match the registered version",
+    "statusCode": 400
+  }
+}

package/index.js

@@ -0,0 +1,5 @@
+/**
+ * Content plugin functionality
+ * @namespace contentplugin
+ */
+export { default } from './lib/ContentPluginModule.js'

package/lib/ContentPluginModule.js

@@ -0,0 +1,438 @@
+import AbstractApiModule from 'adapt-authoring-api'
+import apidefs from './apidefs.js'
+import fs from 'fs/promises'
+import { glob } from 'glob'
+import path from 'path'
+import semver from 'semver'
+/**
+ * Abstract module which handles framework plugins
+ * @memberof contentplugin
+ * @extends {AbstractApiModule}
+ */
+class ContentPluginModule extends AbstractApiModule {
+  /** @override */
+  async setValues () {
+    /** @ignore */ this.collectionName = 'contentplugins'
+    /** @ignore */ this.root = 'contentplugins'
+    /** @ignore */ this.schemaName = 'contentplugin'
+    /**
+     * Reference to all content plugin schemas, grouped by plugin
+     * @type {Object}
+     */
+    this.pluginSchemas = {}
+    /**
+     * A list of newly installed plugins
+     * @type {Array}
+     */
+    this.newPlugins = []
+
+    const middleware = await this.app.waitForModule('middleware')
+
+    this.useDefaultRouteConfig()
+    // remove unnecessary routes
+    delete this.routes.find(r => r.route === '/').handlers.post
+    delete this.routes.find(r => r.route === '/:_id').handlers.put
+    // extra routes
+    this.routes.push({
+      route: '/install',
+      handlers: {
+        post: [
+          middleware.fileUploadParser(middleware.zipTypes, { unzip: true }),
+          this.installHandler.bind(this)
+        ]
+      },
+      permissions: { post: ['install:contentplugin'] },
+      validate: false,
+      meta: apidefs.install
+    },
+    {
+      route: '/:_id/update',
+      handlers: { post: this.updateHandler.bind(this) },
+      permissions: { post: ['update:contentplugin'] },
+      meta: apidefs.update
+    },
+    {
+      route: '/:_id/uses',
+      handlers: { get: this.usesHandler.bind(this) },
+      permissions: { get: ['read:contentplugin'] },
+      meta: apidefs.uses
+    })
+  }
+
+  /** @override */
+  async init () {
+    await super.init()
+    // env var used by the CLI
+    if (!process.env.ADAPT_ALLOW_PRERELEASE) {
+      process.env.ADAPT_ALLOW_PRERELEASE = 'true'
+    }
+    const [framework, mongodb] = await this.app.waitForModule('adaptframework', 'mongodb')
+
+    await mongodb.setIndex(this.collectionName, 'name', { unique: true })
+    await mongodb.setIndex(this.collectionName, 'displayName', { unique: true })
+    await mongodb.setIndex(this.collectionName, 'type')
+    /**
+     * Cached module instance for easy access
+     * @type {AdaptFrameworkModule}
+     */
+    this.framework = framework
+
+    try {
+      await this.initPlugins()
+    } catch (e) {
+      this.log('error', e)
+    }
+    this.framework.postInstallHook.tap(this.syncPluginData.bind(this))
+    this.framework.postUpdateHook.tap(this.syncPluginData.bind(this))
+  }
+
+  /** @override */
+  async find (query = {}, options = {}, mongoOptions = {}) {
+    const includeUpdateInfo = options.includeUpdateInfo === true || options.includeUpdateInfo === 'true'
+    // special option that's passed via query
+    delete query.includeUpdateInfo
+    const results = await super.find(query, options, mongoOptions)
+    if (includeUpdateInfo) {
+      const updateInfo = await this.framework.runCliCommand('getPluginUpdateInfos', { plugins: results.map(r => r.name) })
+      results.forEach(r => {
+        const info = updateInfo.find(i => i.name === r.name)
+        if (info) {
+          r.canBeUpdated = info.canBeUpdated
+          r.latestCompatibleVersion = info.latestCompatibleSourceVersion
+          r._cliData = info
+        }
+      })
+    }
+    return results
+  }
+
+  async readJson(filepath) {
+    return JSON.parse(await fs.readFile(filepath))
+  }
+
+  /**
+   * Inserts a new document or performs an update if matching data already exists
+   * @param {Object} data Data to be sent to the DB
+   * @param {Object} options Options to pass to the DB function
+   * @returns {Promise} Resolves with the returned data
+   */
+  async insertOrUpdate (data, options = { useDefaults: true }) {
+    return !(await this.find({ name: data.name })).length
+      ? this.insert(data, options)
+      : this.update({ name: data.name }, data, options)
+  }
+
+  /** @override */
+  async delete (query, options, mongoOptions) {
+    const _id = query._id
+    const courses = await this.getPluginUses(_id)
+    if (courses.length) {
+      throw this.app.errors.CONTENTPLUGIN_IN_USE.setData({ courses })
+    }
+    const [pluginData] = await this.find({ _id })
+    // unregister any schemas
+    const jsonschema = await this.app.waitForModule('jsonschema')
+    const schemaPaths = await glob(`src/*/${pluginData.name}/schema/*.schema.json`, { cwd: this.framework.path, absolute: true })
+    schemaPaths.forEach(s => jsonschema.deregisterSchema(s))
+
+    await this.framework.runCliCommand('uninstallPlugins', { plugins: [pluginData.name] })
+    this.log('info', `successfully removed plugin ${pluginData.name}`)
+    return super.delete(query, options, mongoOptions)
+  }
+
+  /**
+   * Initialises all framework plugins, from adapt.json and local cache
+   * @return {Promise}
+   */
+  async initPlugins () {
+    await this.syncPluginData()
+
+    const missing = await this.getMissingPlugins()
+    if (missing.length) { // note we're using CLI directly, as plugins already exist in the DB
+      this.log('debug', 'MISSING', missing)
+      await this.framework.runCliCommand('installPlugins', { plugins: missing })
+    }
+    await this.processPluginSchemas()
+  }
+
+  /**
+   * Makes sure the database plugin data is in sync with the currently installed framework plugins
+   */
+  async syncPluginData() {
+    const dbInfo = (await this.find()).reduce((memo, info) => Object.assign(memo, { [info.name]: info }), {})
+    for (const i of await this.framework.runCliCommand('getPluginUpdateInfos')) {
+      if(dbInfo[i.name]?.version !== i.matchedVersion) {
+        this.log('debug', 'SYNC', i.name, 'local:', dbInfo[i.name]?.version, 'fw:', i.matchedVersion)
+        await this.insertOrUpdate({ ...(await i.getInfo()), type: await i.getType(), isLocalInstall: i.isLocalSource })
+      }
+    }
+  }
+
+  /**
+   * Returns a list of plugins defined in the database but not installed in the framework
+   * @return {Array} List of plugin names mapped to version/dir
+   */
+  async getMissingPlugins() {
+    const dbPlugins = await this.find()
+    const fwPlugins = await this.framework.getInstalledPlugins()
+    return dbPlugins
+      .filter(dbP => !fwPlugins.find(fwP => dbP.name === fwP.name))
+      .map(p => `${p.name}@${p.isLocalInstall ? path.join(this.getConfig('pluginDir'), p.name) : p.version}`)
+  }
+
+  /**
+   * Loads and processes all installed content plugin schemas
+   * @param {Array} pluginInfo Plugin info data
+   * @return {Promise}
+   */
+  async processPluginSchemas (pluginInfo) {
+    if (!pluginInfo) {
+      pluginInfo = await this.framework.runCliCommand('getPluginUpdateInfos')
+    }
+    const jsonschema = await this.app.waitForModule('jsonschema')
+    return Promise.all(pluginInfo.map(async plugin => {
+      const name = plugin.name
+      const oldSchemaPaths = this.pluginSchemas[name]
+      if (oldSchemaPaths) {
+        Object.values(oldSchemaPaths).forEach(s => jsonschema.deregisterSchema(s))
+        delete this.pluginSchemas[name]
+      }
+      const schemaPaths = await plugin.getSchemaPaths()
+      return Promise.all(schemaPaths.map(async schemaPath => {
+        const schema = await this.readJson(schemaPath)
+        const source = schema?.$patch?.source?.$ref
+        if (source) {
+          if (!this.pluginSchemas[name]) this.pluginSchemas[name] = []
+          if (this.pluginSchemas[name].includes(schema.$anchor)) jsonschema.deregisterSchema(this.pluginSchemas[name][source])
+          this.pluginSchemas[name].push(schema.$anchor)
+        }
+        return jsonschema.registerSchema(schemaPath, { replace: true })
+      }))
+    }))
+  }
+
+  /**
+   * Returns whether a schema is registered by a plugin
+   * @param {String} schemaName Name of the schema to check
+   * @return {Boolean}
+   */
+  isPluginSchema (schemaName) {
+    for (const p in this.pluginSchemas) {
+      if (this.pluginSchemas[p].includes(schemaName)) return true
+    }
+  }
+
+  /**
+   * Returns all schemas registered by a plugin
+   * @param {String} pluginName Plugin name
+   * @return {Array} List of the plugin's registered schemas
+   */
+  getPluginSchemas (pluginName) {
+    return this.pluginSchemas[pluginName] ?? []
+  }
+
+  /**
+   * Retrieves the courses in which a plugin is used
+   * @param {String} pluginId Plugin _id
+   * @returns {Promise} Resolves with an array of course data
+   */
+  async getPluginUses (pluginId) {
+    const [{ name }] = await this.find({ _id: pluginId })
+    const [content, db] = await this.app.waitForModule('content', 'mongodb')
+    return (db.getCollection(content.collectionName).aggregate([
+      { $match: { _type: 'config', _enabledPlugins: name } },
+      { $lookup: { from: 'content', localField: '_courseId', foreignField: '_id', as: 'course' } },
+      { $unwind: '$course' },
+      { $replaceRoot: { newRoot: '$course' } },
+      { $lookup: { from: 'users', localField: 'createdBy', foreignField: '_id', as: 'createdBy' } },
+      { $project: { title: 1, createdBy: { $map: { input: '$createdBy', as: 'user', in: '$$user.email' } } } },
+      { $unwind: '$createdBy' }
+    ])).toArray()
+  }
+
+  /**
+   * Installs new plugins
+   * @param {Array[]} plugins 2D array of strings in the format [pluginName, versionOrPath]
+   * @param {Object} options
+   * @param {Boolean} options.force Whether the plugin should be 'force' installed if version is lower than the existing
+   * @param {Boolean} options.strict Whether the function should fail on error
+   */
+  async installPlugins (plugins, options = { strict: false, force: false }) {
+    const errors = []
+    const installed = []
+    await Promise.all(plugins.map(async ([name, versionOrPath]) => {
+      try {
+        const data = await this.installPlugin(name, versionOrPath, options)
+        installed.push(data)
+        this.log('info', 'PLUGIN_INSTALL', `${data.name}@${data.version}`)
+      } catch (e) {
+        this.log('warn', 'PLUGIN_INSTALL_FAIL', name, e?.data?.error ?? e)
+        errors.push(e)
+      }
+    }))
+    if (errors.length && options.strict) {
+      throw this.app.errors.CONTENTPLUGIN_INSTALL_FAILED
+        .setData({ errors })
+    }
+    return installed
+  }
+
+  /**
+   * Installs a single plugin. Note: this function is called by installPlugins and should not be called directly.
+   * @param {String} pluginName Name of the plugin to install
+   * @param {String} versionOrPath The semver-formatted version, or the path to the plugin source
+   * @param {Object} options
+   * @param {Boolean} options.force Whether the plugin should be 'force' installed if version is lower than the existing
+   * @param {Boolean} options.strict Whether the function should fail on error
+   * @returns Resolves with plugin DB data
+   */
+  async installPlugin (pluginName, versionOrPath, options = { strict: false, force: false }) {
+    const [pluginData] = await this.find({ name: String(pluginName) }, { includeUpdateInfo: true })
+    const { name, version, sourcePath, isLocalInstall } = await this.processPluginFiles({ ...pluginData, sourcePath: versionOrPath })
+    const [ existingPlugin ] = await this.find({ name })
+
+    if (existingPlugin) {
+      if (!options.force && semver.lte(version, existingPlugin.version)) {
+        throw this.app.errors.CONTENTPLUGIN_ALREADY_EXISTS
+          .setData({ name: existingPlugin.name, version: existingPlugin.version })
+      }
+    }
+    const [data] = await this.framework.runCliCommand('installPlugins', { plugins: [`${name}@${sourcePath ?? version}`] })
+    const info = await this.insertOrUpdate({
+      ...(await data.getInfo()),
+      type: await data.getType(),
+      isLocalInstall
+    })
+    if (!data.isInstallSuccessful) {
+      throw this.app.errors.CONTENTPLUGIN_CLI_INSTALL_FAILED
+        .setData({ name })
+    }
+    if (!info.targetAttribute) {
+      throw this.app.errors.CONTENTPLUGIN_ATTR_MISSING
+        .setData({ name })
+    }
+    await this.processPluginSchemas([data])
+    return info
+  }
+
+  /**
+   * Ensures local plugin source files are stored in the correct location and structured in an expected way
+   * @param {Object} pluginData Plugin metadata
+   * @param {String} sourcePath The path to the plugin source files
+   * @returns Resolves with package data
+   */
+  async processPluginFiles (pluginData) {
+    let sourcePath = pluginData.sourcePath
+    if (sourcePath === path.basename(sourcePath)) { // no local files
+      return { name: pluginData.name, version: sourcePath, isLocalInstall: false }
+    }
+    const contents = await fs.readdir(sourcePath)
+    if (contents.length === 1) { // deal with a nested root folder
+      sourcePath = path.join(pluginData.sourcePath, contents[0])
+    }
+    let pkg
+    try { // load package data, with fall-back to bower
+      try {
+        pkg = await this.readJson(path.join(sourcePath, 'package.json'))
+      } catch (e) {
+        pkg = await this.readJson(path.join(sourcePath, 'bower.json'))
+      }
+      pkg.sourcePath = path.join(this.getConfig('pluginDir'), pkg.name)
+      pkg.isLocalInstall = true
+    } catch (e) {
+      throw this.app.errors.CONTENTPLUGIN_INVALID_ZIP
+    }
+    // move the files into the persistent location
+    await fs.cp(sourcePath, pkg.sourcePath, { recursive: true })
+    await fs.rm(sourcePath, { recursive: true })
+    return pkg
+  }
+
+  /**
+   * Updates a single plugin
+   * @param {String} _id The _id for the plugin to update
+   * @return Resolves with update data
+   */
+  async updatePlugin (_id) {
+    const [{ name }] = await this.find({ _id })
+    const [pluginData] = await this.framework.runCliCommand('updatePlugins', { plugins: [name] })
+    const p = await this.update({ name }, pluginData._sourceInfo)
+    await this.processPluginSchemas(pluginData)
+    this.log('info', `successfully updated plugin ${p.name}@${p.version}`)
+    return p
+  }
+
+  /** @override */
+  serveSchema () {
+    return async (req, res, next) => {
+      try {
+        const plugin = await this.get({ name: req.apiData.query.type }) || {}
+        const schema = await this.getSchema(plugin.schemaName)
+        if (!schema) {
+          return res.sendError(this.app.errors.NOT_FOUND.setData({ type: 'schema', id: plugin.schemaName }))
+        }
+        res.type('application/schema+json').json(schema)
+      } catch (e) {
+        return next(e)
+      }
+    }
+  }
+
+  /**
+   * Express request handler for installing a plugin (also used for updating via zip upload).
+   * @param {external:ExpressRequest} req
+   * @param {external:ExpressResponse} res
+   * @param {Function} next
+   */
+  async installHandler (req, res, next) {
+    try {
+      const [pluginData] = await this.installPlugins([
+        [
+          req.body.name,
+          req?.fileUpload?.files?.file?.[0]?.filepath ?? req.body.version
+        ]
+      ], {
+        force: req.body.force === 'true' || req.body.force === true,
+        strict: true
+      })
+      res.status(this.mapStatusCode('post')).send(pluginData)
+    } catch (error) {
+      if (error.code === this.app.errors.CONTENTPLUGIN_INSTALL_FAILED.code) {
+        error.data.errors = error.data.errors.map(req.translate)
+      }
+      res.sendError(error)
+    }
+  }
+
+  /**
+   * Express request handler for updating a plugin
+   * @param {external:ExpressRequest} req
+   * @param {external:ExpressResponse} res
+   * @param {Function} next
+   */
+  async updateHandler (req, res, next) {
+    try {
+      const pluginData = await this.updatePlugin(req.params._id)
+      res.status(this.mapStatusCode('put')).send(pluginData)
+    } catch (error) {
+      return next(error)
+    }
+  }
+
+  /**
+   * Express request handler for retrieving uses of a single plugin
+   * @param {external:ExpressRequest} req
+   * @param {external:ExpressResponse} res
+   * @param {Function} next
+   */
+  async usesHandler (req, res, next) {
+    try {
+      const data = await this.getPluginUses(req.params._id)
+      res.status(this.mapStatusCode('put')).send(data)
+    } catch (error) {
+      return next(error)
+    }
+  }
+}
+
+export default ContentPluginModule

package/lib/apidefs.js

@@ -0,0 +1,67 @@
+export default {
+  update: {
+    post: {
+      summary: 'Update a single content plugin',
+      parameters: [{ name: '_id', in: 'path', description: 'Content plugin _id', required: true }],
+      responses: {
+        200: {
+          description: '',
+          content: {
+            'application/json': {
+              schema: { $ref: '#components/schemas/contentplugin' }
+            }
+          }
+        }
+      }
+    }
+  },
+  uses: {
+    get: {
+      summary: 'Return courses using a single content plugin',
+      parameters: [{ name: '_id', in: 'path', description: 'Content plugin _id', required: true }],
+      responses: {
+        200: {
+          description: '',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'array',
+                items: { $ref: '#components/schemas/course' }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  install: {
+    post: {
+      summary: 'Import an Adapt course',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                version: { type: 'string' },
+                force: { type: 'Boolean', default: false }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: '',
+          content: {
+            'application/json': {
+              schema: { $ref: '#components/schemas/contentplugin' }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "adapt-authoring-contentplugin",
+  "version": "0.0.1",
+  "description": "Module for managing framework plugins",
+  "homepage": "https://github.com/adapt-security/adapt-authoring-contentplugin",
+  "main": "index.js",
+  "type": "module",
+  "dependencies": {
+    "adapt-cli": "github:adaptlearning/adapt-cli#v3.3.2",
+    "glob": "^11.0.0",
+    "semver": "^7.6.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.12.0",
+    "standard": "^17.1.0"
+  }
+}

package/schema/contentplugin.schema.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$anchor": "contentplugin",
+  "description": "An Adapt framework plugin",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "Unique name for the plugin",
+      "type": "string"
+    },
+    "displayName": {
+      "description": "User-friendly name for the plugin",
+      "type": "string"
+    },
+    "version": {
+      "description": "Version number for the plugin",
+      "type": "string"
+    },
+    "framework": {
+      "description": "",
+      "type": "string"
+    },
+    "isLocalInstall": {
+      "description": "Whether the plugin has been installed locally (as opposed to with the CLI)",
+      "type": "boolean"
+    },
+    "isEnabled": {
+      "description": "",
+      "type": "boolean",
+      "default": true
+    },
+    "type": {
+      "description": "",
+      "type": "string"
+    },
+    "targetAttribute": {
+      "description": "",
+      "type": "string"
+    },
+    "description": {
+      "description": "",
+      "type": "string"
+    },
+    "pluginDependencies": {
+      "description": "",
+      "type": "object"
+    },
+    "canBeUpdated" : {
+      "type": "boolean",
+      "isReadOnly": true
+    },
+    "latestCompatibleVersion" : {
+      "type": "boolean",
+      "isReadOnly": true
+    }
+  },
+  "required": ["framework", "name", "type", "version", "isLocalInstall"]
+}