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

@@ -0,0 +1,18 @@
+{
+  "INVALID_PARENT": {
+    "data": {
+      "parentId": "_id of the parent item"
+    },
+    "description": "Specified item is not a valid content item Invalid parent itemparent",
+    "statusCode": 500
+  },
+  "UNKNOWN_SCHEMA_NAME": {
+    "data": {
+      "_id": "The database _id",
+      "_type": "The _type value",
+      "_component": "The _component value"
+    },
+    "description": "Failed to determine schema name",
+    "statusCode": 500
+  }
+}

package/index.js

@@ -0,0 +1,5 @@
+/**
+ * Functionality related to course content
+ * @namespace content
+ */
+export { default } from './lib/ContentModule.js'

package/lib/ContentModule.js

@@ -0,0 +1,384 @@
+import { AbstractApiModule, AbstractApiUtils } from 'adapt-authoring-api'
+import apidefs from './apidefs.js'
+/**
+ * Module which handles course content
+ * @memberof content
+ * @extends {AbstractApiModule}
+ */
+class ContentModule extends AbstractApiModule {
+  /** @override */
+  async setValues () {
+    const server = await this.app.waitForModule('server')
+    /** @ignore */ this.root = 'content'
+    /** @ignore */ this.collectionName = 'content'
+    /** @ignore */ this.schemaName = 'content'
+    /** @ignore */ this.router = server.api.createChildRouter('content')
+    this.useDefaultRouteConfig()
+    /** @ignore */ this.routes = [
+      {
+        route: '/insertrecusive',
+        handlers: { post: this.handleInsertRecursive.bind(this) },
+        permissions: { post: ['write:content'] },
+        meta: apidefs.insertrecursive
+      },
+      {
+        route: '/clone',
+        handlers: { post: this.handleClone.bind(this) },
+        permissions: { post: ['write:content'] },
+        meta: apidefs.clone
+      },
+      ...this.routes
+    ]
+  }
+
+  /** @override */
+  async init () {
+    await super.init()
+
+    const [authored, jsonschema, mongodb, tags] = await this.app.waitForModule('authored', 'jsonschema', 'mongodb', 'tags')
+
+    await authored.registerModule(this)
+    await tags.registerModule(this)
+    /**
+     * we have to extend config specifically here because it doesn't use the default content schema
+     */
+    jsonschema.registerSchemasHook.tap(this.registerConfigSchemas.bind(this))
+    await this.registerConfigSchemas()
+
+    await mongodb.setIndex(this.collectionName, { _courseId: 1, _parentId: 1, _type: 1 })
+  }
+
+  /** @override */
+  async getSchemaName (data) {
+    const contentplugin = await this.app.waitForModule('contentplugin')
+    let { _component, _id, _type } = data
+    const defaultSchemaName = super.getSchemaName(data)
+
+    if (_id && (!_type || !_component)) { // no explicit type, so look for record in the DB
+      const [item] = await this.find({ _id }, { validate: false })
+      if (item) {
+        _type = item._type
+        _component = item._component
+      }
+    }
+    if (!_type && !_component) { // can't go any further, return default value
+      return defaultSchemaName
+    }
+    if (_type !== 'component') {
+      return _type === 'page' || _type === 'menu' ? 'contentobject' : _type
+    }
+    const [component] = await contentplugin.find({ name: _component }, { validate: false })
+    return component ? `${component.targetAttribute.slice(1)}-component` : defaultSchemaName
+  }
+
+  /** @override */
+  async getSchema (schemaName, data) {
+    const jsonschema = await this.app.waitForModule('jsonschema')
+    try { // try and determine a more specific schema
+      schemaName = await this.getSchemaName(data)
+    } catch (e) {}
+    const contentplugin = await this.app.waitForModule('contentplugin')
+    const _courseId = data._courseId ??
+      (data._id ? (await this.find({ _id: data._id }, { validate: false }))[0]?._courseId : undefined)
+    let enabledPluginSchemas = []
+    if (_courseId) {
+      try {
+        const [config] = await this.find({ _type: 'config', _courseId }, { validate: false })
+        enabledPluginSchemas = config._enabledPlugins.reduce((m, p) => [...m, ...contentplugin.getPluginSchemas(p)], [])
+      } catch (e) {}
+    }
+    return jsonschema.getSchema(schemaName, {
+      useCache: false,
+      extensionFilter: s => contentplugin.isPluginSchema(s) ? enabledPluginSchemas.includes(s) : true
+    })
+  }
+
+  /**
+   * Adds config schema extensions
+   */
+  async registerConfigSchemas () {
+    const [authored, jsonschema, tags] = await this.app.waitForModule('authored', 'jsonschema', 'tags')
+    jsonschema.extendSchema('config', authored.schemaName)
+    jsonschema.extendSchema('config', tags.schemaExtensionName)
+  }
+
+  /** @override */
+  async insert (data, options = {}, mongoOptions = {}) {
+    const doc = await super.insert(data, options, mongoOptions)
+
+    if (doc._type === 'course') { // add the _courseId to a new course to make querying easier
+      return this.update({ _id: doc._id }, { _courseId: doc._id.toString() })
+    }
+    await Promise.all([
+      options.updateSortOrder !== false && this.updateSortOrder(doc, data),
+      options.updateEnabledPlugins !== false && this.updateEnabledPlugins(doc)
+    ])
+    return doc
+  }
+
+  /** @override */
+  async update (query, data, options, mongoOptions) {
+    const doc = await super.update(query, data, options, mongoOptions)
+    await Promise.all([
+      this.updateSortOrder(doc, data),
+      this.updateEnabledPlugins(doc, data._enabledPlugins ? { forceUpdate: true } : {})
+    ])
+    return doc
+  }
+
+  /** @override */
+  async delete (query, options, mongoOptions) {
+    this.setDefaultOptions(options)
+
+    const [targetDoc] = await this.find(query)
+
+    if (!targetDoc) {
+      throw this.app.errors.NOT_FOUND.setData({ type: options.schemaName, id: JSON.stringify(query) })
+    }
+    const descendants = await this.getDescendants(targetDoc)
+
+    await Promise.all([...descendants, targetDoc].map(d => {
+      return super.delete({ _id: d._id })
+    }))
+    await Promise.all([
+      this.updateEnabledPlugins(targetDoc),
+      this.updateSortOrder(targetDoc)
+    ])
+    return [targetDoc, ...descendants]
+  }
+
+  /**
+   * Finds all descendant content items for a given root
+   * @param {Object} rootItem The root item document
+   * @returns {Array<Object>} Array of content items
+   */
+  async getDescendants (rootItem) {
+    const courseItems = await this.find({ _courseId: rootItem._courseId })
+    const descendants = []
+    let items = [rootItem]
+    do {
+      items = items.reduce((m, i) => [...m, ...courseItems.filter(c => c._parentId?.toString() === i._id.toString())], [])
+      descendants.push(...items)
+    } while (items.length)
+
+    if (rootItem._type === 'course') {
+      const config = courseItems.find(c => c._type === 'config')
+      if (config) descendants.push(config)
+    }
+    return descendants
+  }
+
+  /**
+   * Creates a new parent content type, along with any necessary children
+   * @param {external:ExpressRequest} req
+   */
+  async insertRecursive (req) {
+    const rootId = req.apiData.query.rootId
+    const createdBy = req.auth.user._id.toString()
+    let childTypes = ['course', 'page', 'article', 'block', 'component']
+    const defaultData = {
+      page: { title: req.translate('app.newpagetitle') },
+      article: { title: req.translate('app.newarticletitle') },
+      block: { title: req.translate('app.newblocktitle') },
+      component: {
+        _component: 'adapt-contrib-text',
+        _layout: 'full',
+        title: req.translate('app.newtextcomponenttitle'),
+        body: req.translate('app.newtextcomponentbody')
+      }
+    }
+    const newItems = []
+    let parent
+    try {
+      // figure out which children need creating
+      if (rootId === undefined) { // new course
+        parent = await this.insert({ _type: 'course', createdBy, ...req.apiData.data }, { schemaName: 'course' })
+        newItems.push(parent)
+        childTypes.splice(0, 1, 'config')
+      } else {
+        parent = (await this.find({ _id: rootId }))[0]
+        // special case for menus
+        req.body?._type === 'menu'
+          ? childTypes.splice(0, 1, 'menu')
+          : childTypes = childTypes.slice(childTypes.indexOf(parent._type) + 1)
+      }
+      for (const _type of childTypes) {
+        const data = Object.assign({ _type, createdBy }, defaultData[_type])
+        if (parent) {
+          Object.assign(data, {
+            _parentId: parent._id.toString(),
+            _courseId: parent._courseId.toString()
+          })
+        }
+        const item = await this.insert(data)
+        newItems.push(item)
+        if (_type !== 'config') parent = item
+      }
+    } catch (e) {
+      await Promise.all(newItems.map(({ _id }) => super.delete({ _id }, { invokePostHook: false })))
+      throw e
+    }
+    // return the topmost new item
+    return newItems[0]
+  }
+
+  /**
+   * Recursively clones a content item
+   * @param {String} userId The user performing the action
+   * @param {String} _id ID of the object to clone
+   * @param {String} _parentId The intended parent object (if this is not passed, no parent will be set)
+   * @param {Object} customData Data to be applied to the content item
+   * @return {Promise}
+   */
+  async clone (userId, _id, _parentId, customData = {}) {
+    const [originalDoc] = await this.find({ _id })
+    if (!originalDoc) {
+      throw this.app.errors.NOT_FOUND
+        .setData({ type: originalDoc?._type, id: _id })
+    }
+    const [parent] = _parentId ? await this.find({ _id: _parentId }) : []
+
+    if (!parent && originalDoc._type !== 'course' && originalDoc._type !== 'config') {
+      throw this.app.errors.INVALID_PARENT.setData({ parentId: _parentId })
+    }
+    const schemaName = originalDoc._type === 'menu' || originalDoc._type === 'page' ? 'contentobject' : originalDoc._type
+    const payload = AbstractApiUtils.stringifyValues({
+      ...originalDoc,
+      _id: undefined,
+      _trackingId: undefined,
+      _courseId: parent?._type === 'course' ? parent?._id : parent?._courseId,
+      _parentId,
+      createdBy: userId,
+      ...customData
+    })
+    const newData = await this.insert(payload, { schemaName })
+
+    if (originalDoc._type === 'course') {
+      const [config] = await this.find({ _type: 'config', _courseId: originalDoc._courseId })
+      await this.clone(userId, config._id, undefined, { _courseId: newData._id.toString() })
+      delete payload._id
+      delete payload._courseId
+      // the config did not exist when the new course object was created
+      // schema validation will have therefore stripped the plugin configuration data
+      // here we restore the configuraton data
+      await this.update({ _id: newData._id }, payload)
+    }
+    const children = await this.find({ _parentId: _id })
+    for (let i = 0; i < children.length; i++) {
+      await this.clone(userId, children[i]._id, newData._id)
+    }
+    return newData
+  }
+
+  /**
+   * Recalculates the _sortOrder values for all content items affected by an update
+   * @param {Object} item The existing item data
+   * @param {Object} updateData The update data
+   * @return {Promise}
+   */
+  async updateSortOrder (item, updateData) {
+    // some exceptions which don't need a _sortOrder
+    if (item._type === 'config' || item._type === 'course' || !item._parentId) {
+      return
+    }
+    const siblings = await this.find({ _parentId: item._parentId, _id: { $ne: item._id } }, {}, { sort: { _sortOrder: 1 } })
+    if (updateData) {
+      const newSO = item._sortOrder - 1 > -1 ? item._sortOrder - 1 : siblings.length
+      siblings.splice(newSO, 0, item)
+    }
+    return Promise.all(siblings.map(async (s, i) => {
+      const _sortOrder = i + 1
+      if (s._sortOrder !== _sortOrder) super.update({ _id: s._id }, { _sortOrder })
+    }))
+  }
+
+  /**
+   * Maintains the list of plugins used in the current course
+   * @param {Object} item The updated item
+   * @param {Object} options
+   * @param {Boolean} options.forceUpdate Forces an update of defaults regardless of whether the _enabledPlugins list has changed
+   * @return {Promise}
+   */
+  async updateEnabledPlugins ({ _courseId }, options = {}) {
+    const [contentplugin, jsonschema] = await this.app.waitForModule('contentplugin', 'jsonschema')
+    const contentItems = await this.find({ _courseId })
+    const config = contentItems.find(c => c._type === 'config')
+
+    if (!config) {
+      return // can't continue if there's no config to update
+    }
+    const extensionNames = (await contentplugin.find({ type: 'extension' })).map(p => p.name)
+    const componentNames = (contentItems.filter(c => c._type === 'component')).map(c => c._component)
+    // generate unique list of used plugins
+    const _enabledPlugins = Array.from(new Set([
+      ...config._enabledPlugins.filter(name => extensionNames.includes(name)), // only extensions, rest are calculated below
+      ...componentNames,
+      config._menu,
+      config._theme
+    ]))
+    if (options.forceUpdate !== true &&
+      config._enabledPlugins.length === _enabledPlugins.length &&
+      config._enabledPlugins.every(p => _enabledPlugins.includes(p))) {
+      return // return early if the lists already match
+    }
+    // generate list of used content types which need defaults applied
+    const types = _enabledPlugins
+      .filter(p => options.forceUpdate || !config._enabledPlugins.includes(p))
+      .reduce((m, p) => m.concat(contentplugin.getPluginSchemas(p)), [])
+      .reduce((types, pluginSchemaName) => {
+        const rawSchema = jsonschema.schemas[pluginSchemaName].raw
+        const type = rawSchema?.$merge?.source?.$ref ?? rawSchema?.$patch?.source?.$ref
+        return (type === 'contentobject' ? ['menu', 'page'] : [type]).reduce((m, t) => {
+          if (t && !m.includes(t)) m.push(t)
+          return m
+        }, types)
+      }, [])
+    // update config._enabledPlugins
+    await super.update({ _courseId, _type: 'config' }, { _enabledPlugins })
+    // update other affected content objects to ensure new defaults are applied
+    // note: due to the complex data, each must be updated separately rather than using updateMany
+    if (types.length > 0) {
+      const toUpdate = await super.find({ _courseId, _type: { $in: types } }, {})
+      return Promise.all(toUpdate.map(c => super.update({ _id: c._id }, {})))
+    }
+  }
+
+  /**
+   * Special request handler for bootstrapping a new content object with dummy content
+   * @param {external:ExpressRequest} req
+   * @param {external:ExpressResponse} res
+   * @param {Function} next
+   */
+  async handleInsertRecursive (req, res, next) {
+    try {
+      res.status(201).json(await this.insertRecursive(req))
+    } catch (e) {
+      return next(e)
+    }
+  }
+
+  /**
+   * Request handler for cloning content items
+   * @param {external:ExpressRequest} req
+   * @param {external:ExpressResponse} res
+   * @param {Function} next
+   * @return {Promise} Resolves with the cloned data
+   */
+  async handleClone (req, res, next) {
+    try {
+      await this.checkAccess(req, req.apiData.query)
+      const { _id, _parentId } = req.body
+
+      const customData = { ...req.body }
+      delete customData._id
+      delete customData._parentId
+
+      const newData = await this.clone(req.auth.user._id, _id, _parentId, customData)
+      res.status(201).json(newData)
+    } catch (e) {
+      return next(e)
+    }
+  }
+}
+
+export default ContentModule

package/lib/apidefs.js

@@ -0,0 +1,50 @@
+export default {
+  clone: {
+    post: {
+      summary: 'Clones a content item',
+      description: 'Duplicates a content item as well as all its children.',
+      responses: {
+        201: {
+          description: 'The newly cloned data',
+          content: {
+            'application/json': {
+              schema: {
+                $schema: 'https://json-schema.org/draft/2020-12/schema',
+                type: 'array',
+                items: { $ref: '#components/schemas/content' }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  insertrecursive: {
+    post: {
+      summary: 'Insert hierarchical content data',
+      description: 'Recursively inserts content data',
+      parameters: [{ name: 'rootId', in: 'path', description: 'The parent content item _id', required: true }],
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: { $ref: '#components/schemas/content' }
+          }
+        }
+      },
+      responses: {
+        201: {
+          description: 'The newly inserted data',
+          content: {
+            'application/json': {
+              schema: {
+                $schema: 'https://json-schema.org/draft/2020-12/schema',
+                type: 'array',
+                items: { $ref: '#components/schemas/content' }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "adapt-authoring-content",
+  "version": "0.0.1",
+  "description": "Module for managing Adapt content",
+  "homepage": "https://github.com/adapt-security/adapt-authoring-content",
+  "license": "GPL-3.0",
+  "type": "module",
+  "main": "index.js",
+  "repository": "github:adapt-security/adapt-authoring-content",
+  "devDependencies": {
+    "eslint": "^9.12.0",
+    "standard": "^17.1.0"
+  }
+}