adapt-authoring-adaptframework 2.0.9 → 2.1.0

package/lib/AdaptFrameworkBuild.js

@@ -1,10 +1,10 @@
 import _ from 'lodash'
 import { App, Hook, ensureDir, writeJson } from 'adapt-authoring-core'
 import { parseObjectId } from 'adapt-authoring-mongodb'
-import { createWriteStream } from 'fs'
+import { createWriteStream } from 'node:fs'
 import AdaptCli from 'adapt-cli'
 import { log, logDir, logMemory, copyFrameworkSource } from './utils.js'
-import fs from 'fs/promises'
+import fs from 'node:fs/promises'
 import path from 'upath'
 import semver from 'semver'
 import zipper from 'zipper'

package/lib/AdaptFrameworkImport.js

@@ -1,6 +1,6 @@
 import { App, Hook, spawn, readJson, writeJson } from 'adapt-authoring-core'
 import { parseObjectId } from 'adapt-authoring-mongodb'
-import fs from 'fs/promises'
+import fs from 'node:fs/promises'
 import { glob } from 'glob'
 import octopus from 'adapt-octopus'
 import path from 'upath'
@@ -630,7 +630,8 @@ class AdaptFrameworkImport {
 
     let managedPluginUpdateBlocked = false
     Object.keys(this.usedContentPlugins).forEach(p => {
-      const installedP = this.installedPlugins[p]
+      const { name: pluginName } = this.usedContentPlugins[p]
+      const installedP = this.installedPlugins[pluginName]
       let { version: importVersion } = this.usedContentPlugins[p]
       if (!semver.valid(importVersion)) {
         if (!installedP) {
@@ -677,8 +678,9 @@ class AdaptFrameworkImport {
       // pre-process: store update metadata and fix missing targetAttributes
       for (const p of allPlugins) {
         const isUpdate = pluginsToUpdate.includes(p)
-        if (isUpdate && this.installedPlugins[p]) {
-          this.updatedContentPlugins[p] = this.installedPlugins[p]
+        const { name: pName } = this.usedContentPlugins[p]
+        if (isUpdate && this.installedPlugins[pName]) {
+          this.updatedContentPlugins[p] = this.installedPlugins[pName]
         }
         const pluginBowerPath = path.join(this.usedContentPlugins[p].path, 'bower.json')
         const bowerJson = await readJson(pluginBowerPath)

package/lib/AdaptFrameworkModule.js

@@ -1,11 +1,11 @@
 import { AbstractModule, Hook, readJson } from 'adapt-authoring-core'
 import AdaptFrameworkBuild from './AdaptFrameworkBuild.js'
 import AdaptFrameworkImport from './AdaptFrameworkImport.js'
-import ApiDefs from './apidefs.js'
-import fs from 'fs/promises'
+import fs from 'node:fs/promises'
 import { getHandler, postHandler, importHandler, postUpdateHandler, getUpdateHandler } from './handlers.js'
+import { loadRouteConfig } from 'adapt-authoring-server'
 import { runCliCommand } from './utils.js'
-import path from 'path'
+import path from 'node:path'
 import semver from 'semver'
 
 /**
@@ -229,44 +229,16 @@ class AdaptFrameworkModule extends AbstractModule {
      * Router for handling all API calls
      * @type {Router}
      */
-    this.apiRouter = server.api.createChildRouter('adapt')
-    this.apiRouter.addRoute(
-      {
-        route: '/preview/:id',
-        handlers: { post: postHandler },
-        meta: ApiDefs.preview
-      },
-      {
-        route: '/publish/:id',
-        handlers: { post: postHandler, get: getHandler },
-        meta: ApiDefs.publish
-      },
-      {
-        route: '/import',
-        handlers: { post: [importHandler] },
-        meta: ApiDefs.import
-      },
-      {
-        route: '/export/:id',
-        handlers: { post: postHandler, get: getHandler },
-        meta: ApiDefs.export
+    const config = await loadRouteConfig(this.rootDir, this, {
+      handlerAliases: { getHandler, postHandler, importHandler, postUpdateHandler, getUpdateHandler }
+    })
+    this.apiRouter = server.api.createChildRouter(config.root)
+    for (const r of config.routes) {
+      this.apiRouter.addRoute(r)
+      if (!r.permissions) continue
+      for (const [method, perms] of Object.entries(r.permissions)) {
+        auth.secureRoute(`${this.apiRouter.path}${r.route}`, method, perms)
       }
-    )
-    auth.secureRoute(`${this.apiRouter.path}/preview/:id`, 'post', ['preview:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/publish/:id`, 'get', ['publish:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/publish/:id`, 'post', ['publish:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/import`, 'post', ['import:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/export/:id`, 'get', ['export:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/export/:id`, 'post', ['export:adapt'])
-    auth.secureRoute(`${this.apiRouter.path}/update`, 'post', ['update:adapt'])
-
-    if (this.getConfig('enableUpdateApi')) {
-      this.apiRouter.addRoute({
-        route: '/update',
-        handlers: { post: postUpdateHandler, get: getUpdateHandler },
-        meta: ApiDefs.update
-      })
-      auth.secureRoute(`${this.apiRouter.path}/update`, 'get', ['update:adapt'])
     }
   }
 

package/lib/handlers.js

@@ -127,8 +127,11 @@ export async function importHandler (req, res, next) {
  */
 export async function postUpdateHandler (req, res, next) {
   try {
-    log('info', 'running framework update')
     const framework = await App.instance.waitForModule('adaptframework')
+    if (!framework.getConfig('enableUpdateApi')) {
+      return next(App.instance.errors.NOT_FOUND.setData({ type: 'route', id: req.originalUrl }))
+    }
+    log('info', 'running framework update')
     const previousVersion = framework.version
     await framework.updateFramework(req.body.version)
     const currentVersion = framework.version !== previousVersion ? framework.version : undefined
@@ -151,6 +154,9 @@ export async function postUpdateHandler (req, res, next) {
 export async function getUpdateHandler (req, res, next) {
   try {
     const framework = await App.instance.waitForModule('adaptframework')
+    if (!framework.getConfig('enableUpdateApi')) {
+      return next(App.instance.errors.NOT_FOUND.setData({ type: 'route', id: req.originalUrl }))
+    }
     const current = framework.version
     const latest = await framework.getLatestVersion()
     res.json({

package/lib/utils/copyFrameworkSource.js

@@ -1,5 +1,5 @@
 import { App } from 'adapt-authoring-core'
-import fs from 'fs/promises'
+import fs from 'node:fs/promises'
 import path from 'upath'
 
 /**

package/lib/utils/log.js

@@ -1,6 +1,6 @@
 import { App } from 'adapt-authoring-core'
 import bytes from 'bytes'
-import fsSync from 'fs'
+import fsSync from 'node:fs'
 import path from 'upath'
 
 let fw

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Adapt framework integration for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-adaptframework",
   "license": "GPL-3.0",
@@ -8,7 +8,7 @@
   "main": "index.js",
   "repository": "github:adapt-security/adapt-authoring-adaptframework",
   "scripts": {
-    "test": "node --test 'tests/**/*.spec.js'"
+    "test": "node --test --test-force-exit --experimental-test-module-mocks 'tests/**/*.spec.js'"
   },
   "dependencies": {
     "adapt-authoring-browserslist": "^1.3.4",
@@ -34,7 +34,7 @@
     "adapt-authoring-auth": "^2.0.0",
     "adapt-authoring-jsonschema": "^1.1.5",
     "adapt-authoring-middleware": "^1.0.1",
-    "adapt-authoring-server": "^2.0.0",
+    "adapt-authoring-server": "^2.1.0",
     "adapt-authoring-tags": "^1.0.1"
   },
   "devDependencies": {

package/routes.json

@@ -0,0 +1,216 @@
+{
+  "root": "adapt",
+  "routes": [
+    {
+      "route": "/preview/:id",
+      "handlers": { "post": "postHandler" },
+      "permissions": { "post": ["preview:adapt"] },
+      "meta": {
+        "post": {
+          "summary": "Build a preview of an Adapt course",
+          "responses": {
+            "200": {
+              "description": "The Adapt build data",
+              "content": {
+                "application/json": {
+                  "schema": { "$ref": "#components/schemas/adaptbuild" }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/publish/:id",
+      "handlers": { "post": "postHandler", "get": "getHandler" },
+      "permissions": { "post": ["publish:adapt"], "get": ["publish:adapt"] },
+      "meta": {
+        "post": {
+          "summary": "Create a publish zip of an Adapt course",
+          "responses": {
+            "200": {
+              "description": "The Adapt build data",
+              "content": {
+                "application/json": {
+                  "schema": { "$ref": "#components/schemas/adaptbuild" }
+                }
+              }
+            }
+          }
+        },
+        "get": {
+          "summary": "Retrieve an Adapt course publish zip",
+          "responses": {
+            "200": {
+              "description": "Course build zip file",
+              "content": { "application/zip": {} }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/import",
+      "handlers": { "post": "importHandler" },
+      "permissions": { "post": ["import:adapt"] },
+      "meta": {
+        "post": {
+          "summary": "Import an Adapt course",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "path": { "type": "String" },
+                    "isDryRun": { "type": "Boolean", "default": false },
+                    "importContent": { "type": "Boolean", "default": true },
+                    "importPlugins": { "type": "Boolean", "default": true },
+                    "updatePlugins": { "type": "Boolean", "default": false }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": {
+              "description": "",
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "properties": {
+                      "title": { "type": "string" },
+                      "courseId": { "type": "string" },
+                      "versions": { "type": "object" },
+                      "content": {
+                        "type": "object",
+                        "properties": {
+                          "course": { "type": "number" },
+                          "config": { "type": "number" },
+                          "menu": { "type": "number" },
+                          "page": { "type": "number" },
+                          "article": { "type": "number" },
+                          "block": { "type": "number" },
+                          "component": { "type": "number" }
+                        }
+                      },
+                      "statusReport": {
+                        "type": "object",
+                        "properties": {
+                          "error": {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "code": { "type": "string" },
+                                "data": { "type": "string" }
+                              }
+                            }
+                          },
+                          "warn": {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "code": { "type": "string" },
+                                "data": { "type": "string" }
+                              }
+                            }
+                          },
+                          "info": {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "code": { "type": "string" },
+                                "data": { "type": "string" }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/export/:id",
+      "handlers": { "post": "postHandler", "get": "getHandler" },
+      "permissions": { "post": ["export:adapt"], "get": ["export:adapt"] },
+      "meta": {
+        "post": {
+          "summary": "Create an export zip of an Adapt course",
+          "responses": {
+            "200": {
+              "description": "The Adapt build data",
+              "content": {
+                "application/json": {
+                  "schema": { "$ref": "#components/schemas/adaptbuild" }
+                }
+              }
+            }
+          }
+        },
+        "get": {
+          "summary": "Retrieve an Adapt course export zip",
+          "responses": {
+            "200": {
+              "description": "Course build zip file",
+              "content": { "application/zip": {} }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/update",
+      "handlers": { "post": "postUpdateHandler", "get": "getUpdateHandler" },
+      "permissions": { "post": ["update:adapt"], "get": ["update:adapt"] },
+      "meta": {
+        "post": {
+          "summary": "Updates the installed framework",
+          "responses": {
+            "200": {
+              "description": "Describes the upgraded elements",
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "properties": {
+                      "from": { "type": "string" },
+                      "to": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "get": {
+          "summary": "Retrieve framework update data",
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "properties": {
+                      "canBeUpdated": { "type": "boolean" },
+                      "currentVersion": { "type": "string" },
+                      "latestCompatibleVersion": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/AdaptFrameworkImport.spec.js

@@ -1,6 +1,16 @@
-import { describe, it } from 'node:test'
+import { describe, it, mock } from 'node:test'
 import assert from 'node:assert/strict'
-import AdaptFrameworkImport from '../lib/AdaptFrameworkImport.js'
+
+// Prevent log() from triggering App.instance boot during tests
+mock.module('../lib/utils/log.js', {
+  namedExports: {
+    log: async () => {},
+    logDir: () => {},
+    logMemory: () => {}
+  }
+})
+
+const { default: AdaptFrameworkImport } = await import('../lib/AdaptFrameworkImport.js')
 
 describe('AdaptFrameworkImport', () => {
   describe('.typeToSchema()', () => {
@@ -324,4 +334,257 @@ describe('AdaptFrameworkImport', () => {
       assert.equal(ctx.contentJson.contentObjects.art1._type, 'article')
     })
   })
+
+  describe('#cleanUp()', () => {
+    const cleanUp = AdaptFrameworkImport.prototype.cleanUp
+
+    it('should call rollback when an error is passed', async () => {
+      let rollbackCalled = false
+      const ctx = {
+        settings: { removeSource: false },
+        rollback: async () => { rollbackCalled = true }
+      }
+      await cleanUp.call(ctx, new Error('test'))
+      assert.equal(rollbackCalled, true)
+    })
+
+    it('should not call rollback when no error is passed', async () => {
+      let rollbackCalled = false
+      const ctx = {
+        settings: { removeSource: false },
+        rollback: async () => { rollbackCalled = true }
+      }
+      await cleanUp.call(ctx, undefined)
+      assert.equal(rollbackCalled, false)
+    })
+
+    it('should run rollback even when removeSource is false', async () => {
+      let rollbackCalled = false
+      const ctx = {
+        settings: { removeSource: false },
+        rollback: async () => { rollbackCalled = true }
+      }
+      await cleanUp.call(ctx, new Error('test'))
+      assert.equal(rollbackCalled, true)
+    })
+  })
+
+  describe('#rollback()', () => {
+    const rollback = AdaptFrameworkImport.prototype.rollback
+
+    function makeRollbackCtx (overrides = {}) {
+      return {
+        newContentPlugins: {},
+        updatedContentPlugins: {},
+        assetMap: {},
+        newTagIds: [],
+        contentJson: { course: {} },
+        idMap: {},
+        contentplugin: null,
+        assets: null,
+        content: null,
+        courseassets: null,
+        ...overrides
+      }
+    }
+
+    it('should uninstall newly installed plugins', async () => {
+      const uninstalled = []
+      const ctx = makeRollbackCtx({
+        contentplugin: {
+          uninstallPlugin: async (id) => uninstalled.push(id)
+        },
+        newContentPlugins: {
+          'adapt-contrib-text': { _id: 'p1', name: 'adapt-contrib-text' },
+          'adapt-contrib-gmcq': { _id: 'p2', name: 'adapt-contrib-gmcq' }
+        }
+      })
+      await rollback.call(ctx)
+      assert.deepEqual(uninstalled.sort(), ['p1', 'p2'])
+    })
+
+    it('should delete imported assets', async () => {
+      const deleted = []
+      const ctx = makeRollbackCtx({
+        assets: {
+          delete: async ({ _id }) => deleted.push(_id)
+        },
+        assetMap: {
+          'course/en/assets/logo.png': 'a1',
+          'course/en/assets/bg.jpg': 'a2'
+        }
+      })
+      await rollback.call(ctx)
+      assert.deepEqual(deleted.sort(), ['a1', 'a2'])
+    })
+
+    it('should delete course content and course assets', async () => {
+      const contentDeleted = []
+      const courseAssetsDeleted = []
+      const ctx = makeRollbackCtx({
+        content: {
+          deleteMany: async (query) => contentDeleted.push(query)
+        },
+        courseassets: {
+          deleteMany: async (query) => courseAssetsDeleted.push(query)
+        },
+        contentJson: { course: { _id: 'oldCourseId' } },
+        idMap: { oldCourseId: '507f1f77bcf86cd799439011' }
+      })
+      await rollback.call(ctx)
+      assert.equal(contentDeleted.length, 1)
+      assert.equal(courseAssetsDeleted.length, 1)
+    })
+
+    it('should skip plugin uninstall when contentplugin is not available', async () => {
+      const ctx = makeRollbackCtx({
+        contentplugin: null,
+        newContentPlugins: { 'adapt-contrib-text': { _id: 'p1', name: 'adapt-contrib-text' } }
+      })
+      await rollback.call(ctx) // should not throw
+    })
+
+    it('should skip asset deletion when assets module is not available', async () => {
+      const ctx = makeRollbackCtx({
+        assets: null,
+        assetMap: { 'some/path.png': 'a1' }
+      })
+      await rollback.call(ctx) // should not throw
+    })
+
+    it('should skip content deletion when course ID is not in idMap', async () => {
+      const deleted = []
+      const ctx = makeRollbackCtx({
+        content: {
+          deleteMany: async (query) => deleted.push(query)
+        },
+        courseassets: {
+          deleteMany: async (query) => deleted.push(query)
+        },
+        contentJson: { course: { _id: 'oldCourseId' } },
+        idMap: {} // no mapping exists
+      })
+      await rollback.call(ctx)
+      assert.equal(deleted.length, 0)
+    })
+
+    it('should continue cleaning up when an individual asset deletion fails', async () => {
+      const deleted = []
+      const ctx = makeRollbackCtx({
+        assets: {
+          delete: async ({ _id }) => {
+            if (_id === 'a1') throw new Error('delete failed')
+            deleted.push(_id)
+          }
+        },
+        assetMap: {
+          'path/a.png': 'a1',
+          'path/b.png': 'a2',
+          'path/c.png': 'a3'
+        }
+      })
+      await rollback.call(ctx)
+      assert.deepEqual(deleted.sort(), ['a2', 'a3'])
+    })
+
+    it('should continue cleaning up when an individual plugin uninstall fails', async () => {
+      const uninstalled = []
+      const ctx = makeRollbackCtx({
+        contentplugin: {
+          uninstallPlugin: async (id) => {
+            if (id === 'p1') throw new Error('uninstall failed')
+            uninstalled.push(id)
+          }
+        },
+        newContentPlugins: {
+          'plugin-a': { _id: 'p1', name: 'plugin-a' },
+          'plugin-b': { _id: 'p2', name: 'plugin-b' }
+        }
+      })
+      await rollback.call(ctx)
+      assert.deepEqual(uninstalled, ['p2'])
+    })
+  })
+
+  describe('#importCoursePlugins() - early missing plugin detection', () => {
+    const importCoursePlugins = AdaptFrameworkImport.prototype.importCoursePlugins
+
+    function makePluginCtx (overrides = {}) {
+      return {
+        configEnabledPlugins: [],
+        usedContentPlugins: {},
+        installedPlugins: {},
+        newContentPlugins: {},
+        updatedContentPlugins: {},
+        pluginsToMigrate: ['core'],
+        componentNameMap: {},
+        settings: { isDryRun: false, importPlugins: true, updatePlugins: false },
+        statusReport: { info: [], warn: [], error: [] },
+        contentplugin: {
+          find: async () => []
+        },
+        ...overrides
+      }
+    }
+
+    it('should report missing plugins in statusReport during dry run', async () => {
+      const ctx = makePluginCtx({
+        configEnabledPlugins: ['adapt-contrib-text', 'adapt-contrib-missing'],
+        usedContentPlugins: { 'adapt-contrib-text': { version: '1.0.0' } },
+        settings: { isDryRun: true, importPlugins: true, updatePlugins: false },
+        contentplugin: { find: async () => [] }
+      })
+      await importCoursePlugins.call(ctx)
+      assert.equal(ctx.statusReport.error.length, 1)
+      assert.equal(ctx.statusReport.error[0].code, 'MISSING_PLUGINS')
+      assert.deepEqual(ctx.statusReport.error[0].data, ['adapt-contrib-missing'])
+    })
+
+    it('should not report error when config plugins exist in the import package', async () => {
+      const ctx = makePluginCtx({
+        configEnabledPlugins: ['adapt-contrib-text'],
+        usedContentPlugins: { 'adapt-contrib-text': { name: 'adapt-contrib-text', version: '1.0.0', type: 'component' } },
+        contentplugin: {
+          find: async () => [{ name: 'adapt-contrib-text', version: '1.0.0', targetAttribute: '_text', isLocalInstall: true }]
+        }
+      })
+      await importCoursePlugins.call(ctx)
+      assert.equal(ctx.statusReport.error.length, 0)
+    })
+
+    it('should not report error when config plugins are installed on the server', async () => {
+      const ctx = makePluginCtx({
+        configEnabledPlugins: ['adapt-contrib-text'],
+        usedContentPlugins: {},
+        contentplugin: {
+          find: async () => [{ name: 'adapt-contrib-text', version: '1.0.0', targetAttribute: '_text' }]
+        }
+      })
+      await importCoursePlugins.call(ctx)
+      assert.equal(ctx.statusReport.error.length, 0)
+    })
+
+    it('should not report error when configEnabledPlugins is empty', async () => {
+      const ctx = makePluginCtx({
+        configEnabledPlugins: [],
+        contentplugin: { find: async () => [] }
+      })
+      await importCoursePlugins.call(ctx)
+      assert.equal(ctx.statusReport.error.length, 0)
+    })
+
+    it('should only flag plugins missing from both package and server', async () => {
+      const ctx = makePluginCtx({
+        configEnabledPlugins: ['adapt-contrib-text', 'adapt-contrib-gmcq', 'adapt-contrib-missing'],
+        usedContentPlugins: { 'adapt-contrib-text': { version: '1.0.0' } },
+        settings: { isDryRun: true, importPlugins: true, updatePlugins: false },
+        contentplugin: {
+          find: async () => [{ name: 'adapt-contrib-gmcq', version: '2.0.0', targetAttribute: '_gmcq' }]
+        }
+      })
+      await importCoursePlugins.call(ctx)
+      assert.equal(ctx.statusReport.error.length, 1)
+      assert.deepEqual(ctx.statusReport.error[0].data, ['adapt-contrib-missing'])
+    })
+  })
 })

package/lib/apidefs.js

@@ -1,153 +0,0 @@
-const responseDataMeta = {
-  200: {
-    description: 'The Adapt build data',
-    content: {
-      'application/json': {
-        schema: { $ref: '#components/schemas/adaptbuild' }
-      }
-    }
-  }
-}
-
-const responseZipMeta = {
-  200: {
-    description: 'Course build zip file',
-    content: { 'application/zip': {} }
-  }
-}
-
-const statusReportItemSchema = {
-  type: 'array',
-  items: {
-    type: 'object',
-    properties: {
-      code: { type: 'string' },
-      data: { type: 'string' }
-    }
-  }
-}
-
-export default {
-  preview: {
-    post: {
-      summary: 'Build a preview of an Adapt course',
-      responses: responseDataMeta
-    }
-  },
-  publish: {
-    post: {
-      summary: 'Create a publish zip of an Adapt course',
-      responses: responseDataMeta
-    },
-    get: {
-      summary: 'Retrieve an Adapt course publish zip',
-      responses: responseZipMeta
-    }
-  },
-  import: {
-    post: {
-      summary: 'Import an Adapt course',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                path: { type: 'String' },
-                isDryRun: { type: 'Boolean', default: false },
-                importContent: { type: 'Boolean', default: true },
-                importPlugins: { type: 'Boolean', default: true },
-                updatePlugins: { type: 'Boolean', default: false }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: '',
-          content: {
-            'application/json': {
-              schema: {
-                properties: {
-                  title: { type: 'string' },
-                  courseId: { type: 'string' },
-                  versions: { type: 'object' },
-                  content: {
-                    type: 'object',
-                    properties: {
-                      course: { type: 'number' },
-                      config: { type: 'number' },
-                      menu: { type: 'number' },
-                      page: { type: 'number' },
-                      article: { type: 'number' },
-                      block: { type: 'number' },
-                      component: { type: 'number' }
-                    }
-                  },
-                  statusReport: {
-                    type: 'object',
-                    properties: {
-                      error: statusReportItemSchema,
-                      warn: statusReportItemSchema,
-                      info: statusReportItemSchema
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  export: {
-    post: {
-      summary: 'Create an export zip of an Adapt course',
-      responses: responseDataMeta
-    },
-    get: {
-      summary: 'Retrieve an Adapt course export zip',
-      responses: responseZipMeta
-    }
-  },
-  update: {
-    post: {
-      summary: 'Updates the installed framework',
-      responses: {
-        200: {
-          description: 'Describes the upgraded elements',
-          content: {
-            'application/json': {
-              schema: {
-                properties: {
-                  from: { type: 'string' },
-                  to: { type: 'string' }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    get: {
-      summary: 'Retrieve framework update data',
-      responses: {
-        200: {
-          content: {
-            'application/json': {
-              schema: {
-                properties: {
-                  canBeUpdated: { type: 'boolean' },
-                  currentVersion: { type: 'string' },
-                  latestCompatibleVersion: { type: 'string' }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}