adapt-authoring-adaptframework 1.12.1 → 2.0.1

package/.github/workflows/releases.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Update npm
         run: npm install -g npm@latest
       - name: Install dependencies
-        run: npm ci
+        run: npm install --legacy-peer-deps
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/standardjs.yml

@@ -8,6 +8,5 @@ jobs:
       - uses: actions/setup-node@master
         with:
           node-version: 'lts/*'
-          cache: 'npm'
-      - run: npm ci
+      - run: npm install --legacy-peer-deps
       - run: npx standard

package/.github/workflows/tests.yml

@@ -10,6 +10,5 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 'lts/*'
-          cache: 'npm'
-      - run: npm ci
+      - run: npm install --legacy-peer-deps
       - run: npm test

package/index.js

@@ -5,4 +5,3 @@
 export { default } from './lib/AdaptFrameworkModule.js'
 export { default as AdaptFrameworkBuild } from './lib/AdaptFrameworkBuild.js'
 export { default as AdaptFrameworkImport } from './lib/AdaptFrameworkImport.js'
-export { default as AdaptFrameworkUtils } from './lib/AdaptFrameworkUtils.js'

package/lib/AdaptFrameworkBuild.js

@@ -1,8 +1,8 @@
 import _ from 'lodash'
-import { App, Hook } from 'adapt-authoring-core'
+import { App, Hook, ensureDir, writeJson } from 'adapt-authoring-core'
 import { createWriteStream } from 'fs'
 import AdaptCli from 'adapt-cli'
-import FWUtils from './AdaptFrameworkUtils.js'
+import { log, logDir, logMemory, copyFrameworkSource } from './utils.js'
 import fs from 'fs/promises'
 import path from 'upath'
 import semver from 'semver'
@@ -152,17 +152,6 @@ class AdaptFrameworkBuild {
   }
 
   /**
-   * Makes sure the directory exists
-   * @param {string} dir
-   */
-  async ensureDir (dir) {
-    try {
-      await fs.mkdir(dir, { recursive: true })
-    } catch (e) {
-      if (e.code !== 'EEXIST') throw e
-    }
-  }
-
   /**
    * Runs the Adapt framework build tools to generate a course build
    * @return {Promise} Resolves with the output directory
@@ -182,19 +171,19 @@ class AdaptFrameworkBuild {
 
     const cacheDir = path.join(framework.getConfig('buildDir'), 'cache')
 
-    await this.ensureDir(this.dir)
-    await this.ensureDir(this.buildDir)
-    await this.ensureDir(cacheDir)
+    await ensureDir(this.dir)
+    await ensureDir(this.buildDir)
+    await ensureDir(cacheDir)
 
-    FWUtils.logDir('dir', this.dir)
-    FWUtils.logDir('buildDir', this.buildDir)
-    FWUtils.logDir('cacheDir', this.cacheDir)
+    logDir('dir', this.dir)
+    logDir('buildDir', this.buildDir)
+    logDir('cacheDir', this.cacheDir)
 
     await this.loadCourseData()
 
     await Promise.all([
       this.copyAssets(),
-      FWUtils.copyFrameworkSource({
+      copyFrameworkSource({
         destDir: this.dir,
         enabledPlugins: this.enabledPlugins.map(p => p.name),
         linkNodeModules: !this.isExport
@@ -204,11 +193,11 @@ class AdaptFrameworkBuild {
 
     await this.writeContentJson()
 
-    FWUtils.logDir('courseDir', this.courseDir)
+    logDir('courseDir', this.courseDir)
 
     if (!this.isExport) {
       try {
-        FWUtils.logMemory()
+        logMemory()
         await AdaptCli.buildCourse({
           cwd: this.dir,
           sourceMaps: !this.isPublish,
@@ -216,9 +205,9 @@ class AdaptFrameworkBuild {
           cachePath: path.resolve(cacheDir, this.courseId),
           logger: { log: (...args) => App.instance.logger.log('debug', 'adapt-cli', ...args) }
         })
-        FWUtils.logMemory()
+        logMemory()
       } catch (e) {
-        FWUtils.logMemory()
+        logMemory()
         throw App.instance.errors.FW_CLI_BUILD_FAILED
           .setData(e)
       }
@@ -405,7 +394,7 @@ class AdaptFrameworkBuild {
       if (a.url) {
         return
       }
-      await this.ensureDir(path.dirname(this.assetData.idMap[a._id]))
+      await ensureDir(path.dirname(this.assetData.idMap[a._id]))
       const inputStream = await assets.createFsWrapper(a).read(a)
       const outputStream = createWriteStream(this.assetData.idMap[a._id])
       inputStream.pipe(outputStream)
@@ -434,10 +423,10 @@ class AdaptFrameworkBuild {
       data.push(this.assetData)
     }
     return Promise.all(data.map(async ({ dir, fileName, data }) => {
-      await this.ensureDir(dir)
+      await ensureDir(dir)
       const filepath = path.join(dir, fileName)
-      const returnData = await FWUtils.writeJson(filepath, data)
-      FWUtils.log('verbose', 'WRITE', filepath)
+      const returnData = await writeJson(filepath, data)
+      log('verbose', 'WRITE', filepath)
       return returnData
     }))
   }

package/lib/AdaptFrameworkImport.js

@@ -1,4 +1,4 @@
-import { App, Hook, Utils } from 'adapt-authoring-core'
+import { App, Hook, spawn, readJson, writeJson } from 'adapt-authoring-core'
 import fs from 'fs/promises'
 import { glob } from 'glob'
 import octopus from 'adapt-octopus'
@@ -6,7 +6,7 @@ import path from 'upath'
 import { randomBytes } from 'node:crypto'
 import semver from 'semver'
 import { unzip } from 'zipper'
-import FWUtils from './AdaptFrameworkUtils.js'
+import { log, logDir, getImportSummary, getImportContentCounts } from './utils.js'
 
 import ComponentTransform from './migrations/component.js'
 import ConfigTransform from './migrations/config.js'
@@ -255,8 +255,8 @@ class AdaptFrameworkImport {
        */
       this.jsonschema = jsonschema
 
-      FWUtils.log('debug', 'IMPORT_USER', this.userId)
-      FWUtils.log('debug', 'IMPORT_SETTINGS', JSON.stringify(this.settings, null, 2))
+      log('debug', 'IMPORT_USER', this.userId)
+      log('debug', 'IMPORT_SETTINGS', JSON.stringify(this.settings, null, 2))
 
       const { isDryRun, importContent, importPlugins, migrateContent } = this.settings
       const tasks = [
@@ -323,11 +323,11 @@ class AdaptFrameworkImport {
       this.framework.log('error', e)
       throw (e?.statusCode ? e : App.instance.errors.FW_IMPORT_INVALID_COURSE.setData({ reason: e.message }))
     }
-    FWUtils.logDir('unzipPath', this.path)
-    FWUtils.logDir('coursePath', this.coursePath)
+    logDir('unzipPath', this.path)
+    logDir('coursePath', this.coursePath)
 
     try {
-      /** @ignore */this.pkg = await FWUtils.readJson(`${this.path}/package.json`)
+      /** @ignore */this.pkg = await readJson(`${this.path}/package.json`)
     } catch (e) {
       throw App.instance.errors.FW_IMPORT_INVALID.setData({ reason: e.message })
     }
@@ -344,7 +344,7 @@ class AdaptFrameworkImport {
       this.statusReport.info.push({ code: 'MIGRATE_CONTENT', data })
     }
     await this.convertSchemas()
-    FWUtils.log('debug', 'preparation tasks completed successfully')
+    log('debug', 'preparation tasks completed successfully')
   }
 
   /**
@@ -354,7 +354,7 @@ class AdaptFrameworkImport {
   async convertSchemas () {
     return octopus.runRecursive({
       cwd: this.path,
-      logger: { log: (...args) => FWUtils.log('debug', ...args) }
+      logger: { log: (...args) => log('debug', ...args) }
     })
   }
 
@@ -369,11 +369,11 @@ class AdaptFrameworkImport {
     }
     try {
       const customStyle = await fs.readFile(customStylePath, 'utf8')
-      const courseJson = await FWUtils.readJson(courseJsonPath)
-      await FWUtils.writeJson(courseJsonPath, { customStyle, ...courseJson })
-      FWUtils.log('info', 'patched course customStyle')
+      const courseJson = await readJson(courseJsonPath)
+      await writeJson(courseJsonPath, { customStyle, ...courseJson })
+      log('info', 'patched course customStyle')
     } catch (e) {
-      FWUtils.log('warn', 'failed to patch course customStyle', e)
+      log('warn', 'failed to patch course customStyle', e)
     }
   }
 
@@ -383,13 +383,13 @@ class AdaptFrameworkImport {
   async patchThemeName () {
     try {
       const configJsonPath = `${this.coursePath}/config.json`
-      const configJson = await FWUtils.readJson(configJsonPath)
+      const configJson = await readJson(configJsonPath)
       if (configJson._theme) return
       configJson._theme = Object.values(this.usedContentPlugins).find(p => p.type === 'theme').name
-      await FWUtils.writeJson(configJsonPath, configJson)
-      FWUtils.log('info', 'patched config _theme')
+      await writeJson(configJsonPath, configJson)
+      log('info', 'patched config _theme')
     } catch (e) {
-      FWUtils.log('warn', 'failed to patch config _theme', e)
+      log('warn', 'failed to patch config _theme', e)
     }
   }
 
@@ -401,14 +401,14 @@ class AdaptFrameworkImport {
     this.assetData = []
     const metaFiles = await glob(`${this.langPath}/assets.json`, { absolute: true })
     if (metaFiles.length) { // process included asset metadata
-      FWUtils.log('debug', 'processing metadata files', metaFiles)
+      log('debug', 'processing metadata files', metaFiles)
       await Promise.all(metaFiles.map(async f => {
-        const metaJson = await FWUtils.readJson(f)
+        const metaJson = await readJson(f)
         Object.entries(metaJson).forEach(([filename, metadata]) => this.assetData.push({ filename, ...metadata }))
       }))
     } else { // process the file metadata manually
       const assetFiles = await glob(`${this.langPath}/*/*`, { absolute: true })
-      FWUtils.log('debug', 'processing asset files manually', assetFiles.length)
+      log('debug', 'processing asset files manually', assetFiles.length)
       this.assetData.push(...assetFiles.map(f => Object.assign({}, { title: path.basename(f), filepath: f })))
     }
     const hasGlobalTags = !!this.tags.length
@@ -431,9 +431,9 @@ class AdaptFrameworkImport {
       }
     }
     await Promise.all(usedPluginPaths.map(async p => {
-      const bowerJson = await FWUtils.readJson(`${p}/bower.json`)
+      const bowerJson = await readJson(`${p}/bower.json`)
       const { name, version, targetAttribute } = bowerJson
-      FWUtils.log('debug', 'found plugin', name)
+      log('debug', 'found plugin', name)
       this.usedContentPlugins[path.basename(p)] = { name, path: p, version, targetAttribute, type: getPluginType(bowerJson) }
     }))
     this.contentJson.config._enabledPlugins = Object.keys(this.usedContentPlugins)
@@ -446,8 +446,8 @@ class AdaptFrameworkImport {
   async loadCourseData () {
     const files = await glob('**/*.json', { cwd: this.langPath, absolute: true, ignore: { ignored: p => p.name === 'assets.json' } })
     const mapped = await Promise.all(files.map(f => this.loadContentFile(f)))
-    this.statusReport.info.push({ code: 'CONTENT_IMPORTED', data: FWUtils.getImportContentCounts(this.contentJson) })
-    FWUtils.log('info', 'loaded course data successfully')
+    this.statusReport.info.push({ code: 'CONTENT_IMPORTED', data: getImportContentCounts(this.contentJson) })
+    log('info', 'loaded course data successfully')
     return mapped
   }
 
@@ -458,7 +458,7 @@ class AdaptFrameworkImport {
   async loadContentFile (filePath) {
     let contents
     try {
-      contents = await FWUtils.readJson(filePath)
+      contents = await readJson(filePath)
     } catch (e) {
       if (e.constructor.name === 'SyntaxError') {
         throw App.instance.errors.FILE_SYNTAX_ERROR.setData({ path: filePath.replace(this.path, ''), message: e.message })
@@ -481,12 +481,12 @@ class AdaptFrameworkImport {
       contents.forEach(c => {
         this.contentJson.contentObjects[c._id] = c
         if (!c._type) {
-          FWUtils.log('warn', App.instance.errors.FW_IMPORT_INVALID_CONTENT.setData({ item: c }))
+          log('warn', App.instance.errors.FW_IMPORT_INVALID_CONTENT.setData({ item: c }))
           this.statusReport.warn.push({ code: 'INVALID_CONTENT', data: c })
         }
       })
     }
-    FWUtils.log('debug', 'LOAD_CONTENT', path.resolve(filePath))
+    log('debug', 'LOAD_CONTENT', path.resolve(filePath))
   }
 
   /**
@@ -494,7 +494,7 @@ class AdaptFrameworkImport {
    * @return {Promise}
    */
   async runGruntMigration (subTask, { outputDir, captureDir, outputFilePath }) {
-    const output = await Utils.spawn({
+    const output = await spawn({
       cmd: 'npx',
       args: ['grunt', `migration:${subTask}`, `--outputdir=${outputDir}`, `--capturedir=${captureDir}`],
       cwd: this.frameworkPath ?? this.framework.path
@@ -517,16 +517,16 @@ class AdaptFrameworkImport {
         captureDir: path.join(`./${migrationId}-migrations`),
         outputFilePath: path.join(this.framework.path, 'migrations', `${migrationId}.txt`)
       }
-      FWUtils.log('debug', 'MIGRATION_ID', migrationId)
-      FWUtils.logDir('captureDir', opts.captureDir)
-      FWUtils.logDir('outputDir', opts.outputDir)
+      log('debug', 'MIGRATION_ID', migrationId)
+      logDir('captureDir', opts.captureDir)
+      logDir('outputDir', opts.outputDir)
 
       await this.runGruntMigration('capture', opts)
       await this.runGruntMigration('migrate', opts)
 
       await fs.rm(path.join(this.framework.path, opts.captureDir), { recursive: true })
     } catch (error) {
-      FWUtils.log('error', 'Migration process failed', error)
+      log('error', 'Migration process failed', error)
       throw App.instance.errors.FW_IMPORT_MIGRATION_FAILED.setData({ reason: error.message })
     }
   }
@@ -568,7 +568,7 @@ class AdaptFrameworkImport {
     if (course.tags) {
       course.tags = course.tags.map(t => existingTagMap[t])
     }
-    FWUtils.log('debug', 'imported tags successfully')
+    log('debug', 'imported tags successfully')
   }
 
   /**
@@ -602,7 +602,7 @@ class AdaptFrameworkImport {
       }
       imagesImported++
     }))
-    FWUtils.log('debug', 'imported course assets successfully')
+    log('debug', 'imported course assets successfully')
     this.statusReport.info.push({ code: 'ASSETS_IMPORTED_SUCCESSFULLY', data: { count: imagesImported } })
   }
 
@@ -632,7 +632,7 @@ class AdaptFrameworkImport {
       const { version: installedVersion, isLocalInstall } = installedP
       if (semver.lt(importVersion, installedVersion)) {
         this.statusReport.info.push({ code: 'PLUGIN_INSTALL_MIGRATING', data: { name: p, installedVersion, importVersion } })
-        FWUtils.log('debug', `migrating '${p}@${importVersion}' during import, installed version is newer (${installedVersion})`)
+        log('debug', `migrating '${p}@${importVersion}' during import, installed version is newer (${installedVersion})`)
         this.pluginsToMigrate.push(p)
         return
       }
@@ -642,12 +642,12 @@ class AdaptFrameworkImport {
       }
       if (semver.eq(importVersion, installedVersion)) {
         this.statusReport.info.push({ code: 'PLUGIN_INSTALL_NOT_NEWER', data: { name: p, installedVersion, importVersion } })
-        FWUtils.log('debug', `not updating '${p}@${importVersion}' during import, installed version is equal to (${installedVersion})`)
+        log('debug', `not updating '${p}@${importVersion}' during import, installed version is equal to (${installedVersion})`)
         return
       }
       if (!isLocalInstall) {
         this.statusReport.warn.push({ code: 'MANAGED_PLUGIN_INSTALL_SKIPPED', data: { name: p, installedVersion, importVersion } })
-        FWUtils.log('debug', `cannot update '${p}' during import, plugin managed via UI`)
+        log('debug', `cannot update '${p}' during import, plugin managed via UI`)
       }
       pluginsToUpdate.push(p)
     })
@@ -670,10 +670,10 @@ class AdaptFrameworkImport {
           }
           // try and infer a targetAttribute if there isn't one
           const pluginBowerPath = path.join(this.usedContentPlugins[p].path, 'bower.json')
-          const bowerJson = await FWUtils.readJson(pluginBowerPath)
+          const bowerJson = await readJson(pluginBowerPath)
           if (!bowerJson.targetAttribute) {
             bowerJson.targetAttribute = `_${bowerJson.component || bowerJson.extension || bowerJson.menu || bowerJson.theme}`
-            await FWUtils.writeJson(pluginBowerPath, bowerJson)
+            await writeJson(pluginBowerPath, bowerJson)
           }
           if (!this.settings.isDryRun) {
             const [pluginData] = await this.contentplugin.installPlugins([[p, this.usedContentPlugins[p].path]], { strict: true })
@@ -684,9 +684,9 @@ class AdaptFrameworkImport {
           this.statusReport.info.push({ code: 'INSTALL_PLUGIN', data: { name: p, version: bowerJson.version } })
         } catch (e) {
           if (e.code === 'EEXIST') {
-            FWUtils.log('warn', 'PLUGIN_ALREADY_EXISTS', p)
+            log('warn', 'PLUGIN_ALREADY_EXISTS', p)
           } else {
-            FWUtils.log('error', 'PLUGIN_IMPORT_FAILED', p, e)
+            log('error', 'PLUGIN_IMPORT_FAILED', p, e)
             errors.push({ plugin: p, error: e.data?.errors?.[0] ?? e })
           }
         }
@@ -699,7 +699,7 @@ class AdaptFrameworkImport {
     this.componentNameMap = Object.values({ ...this.installedPlugins, ...this.newContentPlugins }).reduce((m, v) => {
       return { ...m, [v.targetAttribute.slice(1)]: v.name }
     }, {})
-    FWUtils.log('debug', 'imported course plugins successfully')
+    log('debug', 'imported course plugins successfully')
   }
 
   /**
@@ -744,7 +744,7 @@ class AdaptFrameworkImport {
       }
     }
     if (errors.length) throw App.instance.errors.FW_IMPORT_CONTENT_FAILED.setData({ errors })
-    FWUtils.log('debug', 'imported course data successfully')
+    log('debug', 'imported course data successfully')
   }
 
   /**
@@ -790,7 +790,7 @@ class AdaptFrameworkImport {
     try {
       this.extractAssets(schema.built.properties, insertData)
     } catch (e) {
-      FWUtils.log('error', `failed to extract asset data for attribute '${e.attribute}' of schema '${schemaName}', ${e}`)
+      log('error', `failed to extract asset data for attribute '${e.attribute}' of schema '${schemaName}', ${e}`)
     }
     insertData = await schema.sanitise(insertData)
     let doc
@@ -847,7 +847,7 @@ class AdaptFrameworkImport {
    * @return {Promise}
    */
   async generateSummary () {
-    this.summary = await FWUtils.getImportSummary(this)
+    this.summary = await getImportSummary(this)
   }
 
   /**
@@ -902,10 +902,10 @@ class AdaptFrameworkImport {
 
     const restoreTasks = []
     for (const [pluginName, originalMetadata] of Object.entries(this.updatedContentPlugins)) {
-      FWUtils.log('info', `restoring plugin '${pluginName}' to previous version ${originalMetadata.version}`)
+      log('info', `restoring plugin '${pluginName}' to previous version ${originalMetadata.version}`)
       restoreTasks.push(
         this.contentplugin.restorePluginFromBackup(pluginName)
-          .catch(e => FWUtils.log('error', `failed to restore plugin '${pluginName}' from backup, ${e.message}`))
+          .catch(e => log('error', `failed to restore plugin '${pluginName}' from backup, ${e.message}`))
       )
     }
     return Promise.allSettled(restoreTasks)

package/lib/AdaptFrameworkModule.js

@@ -1,9 +1,10 @@
-import { AbstractModule, Hook } from 'adapt-authoring-core'
+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 FWUtils from './AdaptFrameworkUtils.js'
+import { getHandler, postHandler, importHandler, postUpdateHandler, getUpdateHandler } from './handlers.js'
+import { runCliCommand } from './utils.js'
 import path from 'path'
 import semver from 'semver'
 
@@ -73,10 +74,10 @@ class AdaptFrameworkModule extends AbstractModule {
   }
 
   /**
-   * Reference to AdaptFrameworkUtils#runCliCommand
+   * Reference to runCliCommand utility
    */
   get runCliCommand () {
-    return FWUtils.runCliCommand
+    return runCliCommand
   }
 
   /**
@@ -132,7 +133,7 @@ class AdaptFrameworkModule extends AbstractModule {
    * @return {Promise}
    */
   async getManifestPlugins () {
-    const manifest = await FWUtils.readJson(path.resolve(this.path, 'adapt.json'))
+    const manifest = await readJson(path.resolve(this.path, 'adapt.json'))
     return Object.entries(manifest.dependencies)
   }
 
@@ -220,7 +221,7 @@ class AdaptFrameworkModule extends AbstractModule {
       route: '/preview/:id/{*splat}',
       handlers: {
         get: (req, res, next) => { // fail silently
-          FWUtils.getHandler(req, res, e => e ? res.status(e.statusCode || 500).end() : next())
+          getHandler(req, res, e => e ? res.status(e.statusCode || 500).end() : next())
         }
       }
     })
@@ -232,22 +233,22 @@ class AdaptFrameworkModule extends AbstractModule {
     this.apiRouter.addRoute(
       {
         route: '/preview/:id',
-        handlers: { post: FWUtils.postHandler },
+        handlers: { post: postHandler },
         meta: ApiDefs.preview
       },
       {
         route: '/publish/:id',
-        handlers: { post: FWUtils.postHandler, get: FWUtils.getHandler },
+        handlers: { post: postHandler, get: getHandler },
         meta: ApiDefs.publish
       },
       {
         route: '/import',
-        handlers: { post: [FWUtils.importHandler] },
+        handlers: { post: [importHandler] },
         meta: ApiDefs.import
       },
       {
         route: '/export/:id',
-        handlers: { post: FWUtils.postHandler, get: FWUtils.getHandler },
+        handlers: { post: postHandler, get: getHandler },
         meta: ApiDefs.export
       }
     )
@@ -262,7 +263,7 @@ class AdaptFrameworkModule extends AbstractModule {
     if (this.getConfig('enableUpdateApi')) {
       this.apiRouter.addRoute({
         route: '/update',
-        handlers: { post: FWUtils.postUpdateHandler, get: FWUtils.getUpdateHandler },
+        handlers: { post: postUpdateHandler, get: getUpdateHandler },
         meta: ApiDefs.update
       })
       auth.secureRoute(`${this.apiRouter.path}/update`, 'get', ['update:adapt'])

package/lib/handlers.js

@@ -0,0 +1,164 @@
+import { App, toBoolean } from 'adapt-authoring-core'
+import path from 'upath'
+import semver from 'semver'
+import { inferBuildAction, retrieveBuildData, slugifyTitle, log } from './utils.js'
+
+/**
+ * Handles GET requests to the API
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @return {Promise}
+ */
+export async function getHandler (req, res, next) {
+  const action = inferBuildAction(req)
+  const id = req.params.id
+  let buildData
+  try {
+    buildData = await retrieveBuildData(id)
+  } catch (e) {
+    return next(e)
+  }
+  if (!buildData || new Date(buildData.expiresAt).getTime() < Date.now()) {
+    return next(App.instance.errors.FW_BUILD_NOT_FOUND.setData({ _id: id }))
+  }
+  if (action === 'publish' || action === 'export') {
+    res.set('content-disposition', `attachment; filename="${await slugifyTitle(buildData)}.zip"`)
+    return res.sendFile(path.resolve(buildData.location), e => e && next(e))
+  }
+  if (action === 'preview') {
+    if (!req.auth.user) {
+      return res.status(App.instance.errors.MISSING_AUTH_HEADER.statusCode).end()
+    }
+    const filePath = path.resolve(buildData.location, req.path.slice(req.path.indexOf(id) + id.length + 1) || 'index.html')
+    await res.sendFile(filePath, e => {
+      if (!e) return
+      if (e.code === 'ENOENT') e = App.instance.errors.NOT_FOUND.setData({ type: 'file', id: filePath })
+      next(e)
+    })
+  }
+}
+
+/**
+ * Handles POST requests to the API
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @return {Promise}
+ */
+export async function postHandler (req, res, next) {
+  const framework = await App.instance.waitForModule('adaptframework')
+  const startTime = Date.now()
+  const action = inferBuildAction(req)
+  const courseId = req.params.id
+  const userId = req.auth.user._id.toString()
+
+  log('info', `running ${action} for course '${courseId}' initiated by ${userId}`)
+  try {
+    const { isPreview, buildData } = await framework.buildCourse({ action, courseId, userId })
+    const duration = Math.round((Date.now() - startTime) / 10) / 100
+    log('info', `finished ${action} for course '${courseId}' in ${duration} seconds`)
+    const urlRoot = isPreview ? framework.rootRouter.url : framework.apiRouter.url
+    res.json({
+      [`${action}_url`]: `${urlRoot}/${action}/${buildData._id}/`,
+      versions: buildData.versions
+    })
+  } catch (e) {
+    log('error', `failed to ${action} course '${courseId}'`)
+    return next(e)
+  }
+}
+
+/**
+ * Deals with an incoming course (supports both local zip and remote URL stream)
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @return {Promise}
+ */
+async function handleImportFile (req, res) {
+  const [fw, middleware] = await App.instance.waitForModule('adaptframework', 'middleware')
+  const handler = req.get('Content-Type').indexOf('multipart/form-data') === 0
+    ? middleware.fileUploadParser
+    : middleware.urlUploadParser
+  return new Promise((resolve, reject) => {
+    handler(middleware.zipTypes, { maxFileSize: fw.getConfig('importMaxFileSize'), unzip: true })(req, res, e => e ? reject(e) : resolve())
+  })
+}
+
+/**
+ * Handles POST /import requests to the API
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @return {Promise}
+ */
+export async function importHandler (req, res, next) {
+  try {
+    const framework = await App.instance.waitForModule('adaptframework')
+    let importPath = req.body.importPath
+    if (req.get('Content-Type').indexOf('multipart/form-data') === 0) {
+      await handleImportFile(req, res)
+      const [course] = req.fileUpload.files.course
+      importPath = course.filepath
+    }
+    const importer = await framework.importCourse({
+      importPath,
+      userId: req.auth.user._id.toString(),
+      isDryRun: toBoolean(req.body.dryRun),
+      assetFolders: req.body.formAssetFolders,
+      tags: req.body.tags?.length > 0 ? req.body.tags?.split(',') : [],
+      importContent: toBoolean(req.body.importContent),
+      importPlugins: toBoolean(req.body.importPlugins),
+      migrateContent: toBoolean(req.body.migrateContent),
+      updatePlugins: toBoolean(req.body.updatePlugins)
+    })
+    res.json(importer.summary)
+  } catch (e) {
+    return next(e?.statusCode ? e : App.instance.errors.FW_IMPORT_FAILED.setData({ error: e }))
+  }
+}
+
+/**
+ * Handles POST /update requests to the API
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @return {Promise}
+ */
+export async function postUpdateHandler (req, res, next) {
+  try {
+    log('info', 'running framework update')
+    const framework = await App.instance.waitForModule('adaptframework')
+    const previousVersion = framework.version
+    await framework.updateFramework(req.body.version)
+    const currentVersion = framework.version !== previousVersion ? framework.version : undefined
+    res.json({
+      from: previousVersion,
+      to: currentVersion
+    })
+  } catch (e) {
+    return next(e)
+  }
+}
+
+/**
+ * Handles GET /update requests to the API
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @return {Promise}
+ */
+export async function getUpdateHandler (req, res, next) {
+  try {
+    const framework = await App.instance.waitForModule('adaptframework')
+    const current = framework.version
+    const latest = await framework.getLatestVersion()
+    res.json({
+      canBeUpdated: semver.gt(latest, current),
+      currentVersion: current,
+      latestCompatibleVersion: latest
+    })
+  } catch (e) {
+    return next(e)
+  }
+}