adapt-authoring-adaptframework 1.1.0 → 1.2.0

package/lib/AdaptFrameworkBuild.js

@@ -2,8 +2,8 @@ import _ from 'lodash'
 import { App, Hook } from 'adapt-authoring-core'
 import { createWriteStream } from 'fs'
 import AdaptCli from 'adapt-cli'
-import AdaptFrameworkUtils from './AdaptFrameworkUtils.js'
-import fs from 'fs-extra'
+import FWUtils from './AdaptFrameworkUtils.js'
+import fs from 'fs/promises'
 import path from 'upath'
 import semver from 'semver'
 import zipper from 'zipper'
@@ -175,7 +175,9 @@ class AdaptFrameworkBuild {
     if (!this.expiresAt) {
       this.expiresAt = await AdaptFrameworkBuild.getBuildExpiry()
     }
-    this.dir = path.resolve(framework.getConfig('buildDir'), new Date().getTime().toString())
+    // random suffix to account for parallel builds executed at exactly the same millisecond
+    const randomSuffix = `_${Math.floor(Math.random() * 1000).toString().padStart(4, '0')}`
+    this.dir = path.resolve(framework.getConfig('buildDir'), Date.now() + randomSuffix)
     this.buildDir = path.join(this.dir, 'build')
     this.courseDir = path.join(this.buildDir, 'course')
 
@@ -185,9 +187,9 @@ class AdaptFrameworkBuild {
     await this.ensureDir(this.buildDir)
     await this.ensureDir(cacheDir)
 
-    AdaptFrameworkUtils.logDir('dir', this.dir)
-    AdaptFrameworkUtils.logDir('buildDir', this.buildDir)
-    AdaptFrameworkUtils.logDir('cacheDir', this.cacheDir)
+    FWUtils.logDir('dir', this.dir)
+    FWUtils.logDir('buildDir', this.buildDir)
+    FWUtils.logDir('cacheDir', this.cacheDir)
 
     await this.loadCourseData()
 
@@ -200,11 +202,11 @@ class AdaptFrameworkBuild {
 
     await this.writeContentJson()
 
-    AdaptFrameworkUtils.logDir('courseDir', this.courseDir)
+    FWUtils.logDir('courseDir', this.courseDir)
 
     if (!this.isExport) {
       try {
-        AdaptFrameworkUtils.logMemory()
+        FWUtils.logMemory()
         await AdaptCli.buildCourse({
           cwd: this.dir,
           sourceMaps: !this.isPublish,
@@ -212,9 +214,9 @@ class AdaptFrameworkBuild {
           cachePath: path.resolve(cacheDir, this.courseId),
           logger: { log: (...args) => App.instance.logger.log('debug', 'adapt-cli', ...args) }
         })
-        AdaptFrameworkUtils.logMemory()
+        FWUtils.logMemory()
       } catch (e) {
-        AdaptFrameworkUtils.logMemory()
+        FWUtils.logMemory()
         throw App.instance.errors.FW_CLI_BUILD_FAILED
           .setData(e)
       }
@@ -397,10 +399,11 @@ class AdaptFrameworkBuild {
    */
   async copySource () {
     const { path: fwPath } = await App.instance.waitForModule('adaptframework')
-    const BLACKLIST = ['.git', '.DS_Store', 'thumbs.db', 'node_modules', 'course']
+    const BLACKLIST = ['.git', '.DS_Store', 'thumbs.db', 'node_modules', 'course', 'migrations']
     const ENABLED_PLUGINS = this.enabledPlugins.map(p => p.name)
     const srcDir = path.join(fwPath, 'src')
-    await fs.copy(fwPath, this.dir, {
+    await fs.cp(fwPath, this.dir, {
+      recursive: true,
       filter: f => {
         f = path.normalize(f)
         const [type, name] = path.relative(srcDir, f).split('/')
@@ -456,8 +459,8 @@ class AdaptFrameworkBuild {
     return Promise.all(data.map(async ({ dir, fileName, data }) => {
       await this.ensureDir(dir)
       const filepath = path.join(dir, fileName)
-      const returnData = await fs.writeJson(filepath, data, { spaces: 2 })
-      AdaptFrameworkUtils.log('debug', 'WRITE', filepath)
+      const returnData = await FWUtils.writeJson(filepath, data)
+      FWUtils.log('debug', 'WRITE', filepath)
       return returnData
     }))
   }
@@ -468,9 +471,9 @@ class AdaptFrameworkBuild {
    */
   async createPreview () {
     const tempName = `${this.dir}_temp`
-    await fs.move(path.join(this.dir, 'build'), tempName)
-    await fs.remove(this.dir)
-    await fs.move(tempName, this.dir)
+    await fs.rename(path.join(this.dir, 'build'), tempName)
+    await fs.rm(this.dir, { recursive: true })
+    await fs.rename(tempName, this.dir)
     this.location = this.dir
   }
 
@@ -486,7 +489,7 @@ class AdaptFrameworkBuild {
     }
     const outputPath = `${this.dir}.zip`
     await zipper.zip(zipPath, outputPath, { removeSource: true })
-    await fs.remove(this.dir)
+    await fs.rm(this.dir, { recursive: true })
     this.location = outputPath
   }
 
@@ -518,7 +521,13 @@ class AdaptFrameworkBuild {
     const mongodb = await App.instance.waitForModule('mongodb')
     const query = { action: this.action, createdBy: this.userId }
     const oldBuilds = await mongodb.find(this.collectionName, query)
-    await Promise.all(oldBuilds.map(b => fs.remove(b.location)))
+    await Promise.all(oldBuilds.map(async b => {
+      try {
+        await fs.rm(b.location, { recursive: true })
+      } catch (e) {
+        if (e.code !== 'ENOENT') throw e
+      }
+    }))
     return mongodb.deleteMany(this.collectionName, query)
   }
 }

package/lib/AdaptFrameworkImport.js

@@ -1,11 +1,11 @@
 import { App } from 'adapt-authoring-core'
-import fs from 'fs-extra'
+import fs from 'fs/promises'
 import { glob } from 'glob'
 import octopus from 'adapt-octopus'
 import path from 'upath'
 import semver from 'semver'
 
-import AdaptFrameworkUtils from './AdaptFrameworkUtils.js'
+import FWUtils from './AdaptFrameworkUtils.js'
 
 import ComponentTransform from './migrations/component.js'
 import ConfigTransform from './migrations/config.js'
@@ -217,9 +217,9 @@ class AdaptFrameworkImport {
        */
       this.jsonschema = jsonschema
 
-      AdaptFrameworkUtils.log('info', `running with settings ${JSON.stringify(this.settings, null, 2)}`)
-      AdaptFrameworkUtils.log('debug', 'IMPORT_SETTINGS', JSON.stringify(this.settings, null, 2))
-      AdaptFrameworkUtils.log('debug', 'IMPORT_USER', this.userId)
+      FWUtils.log('info', `running with settings ${JSON.stringify(this.settings, null, 2)}`)
+      FWUtils.log('debug', 'IMPORT_SETTINGS', JSON.stringify(this.settings, null, 2))
+      FWUtils.log('debug', 'IMPORT_USER', this.userId)
 
       const { isDryRun, importContent, importPlugins } = this.settings
       const tasks = [
@@ -257,8 +257,8 @@ class AdaptFrameworkImport {
         const nestDir = `${this.unzipPath}/${files[0]}`
         await fs.stat(`${nestDir}/package.json`)
         const newDir = path.join(`${this.unzipPath}_2`)
-        await fs.move(nestDir, newDir)
-        await fs.remove(this.unzipPath)
+        await fs.rename(nestDir, newDir)
+        await fs.rm(this.unzipPath, { recursive: true })
         this.unzipPath = newDir
       }
     } catch (e) {
@@ -269,15 +269,15 @@ class AdaptFrameworkImport {
       await fs.stat(f)
       this.coursePath = f
     }))
-    AdaptFrameworkUtils.logDir('unzipPath', this.unzipPath)
+    FWUtils.logDir('unzipPath', this.unzipPath)
 
     if (!this.coursePath) {
       throw App.instance.errors.FW_IMPORT_INVALID_COURSE
     }
-    AdaptFrameworkUtils.logDir('coursePath', this.coursePath)
+    FWUtils.logDir('coursePath', this.coursePath)
 
     try {
-      /** @ignore */this.pkg = await fs.readJson(`${this.unzipPath}/package.json`)
+      /** @ignore */this.pkg = await FWUtils.readJson(`${this.unzipPath}/package.json`)
     } catch (e) {
       throw App.instance.errors.FW_IMPORT_INVALID
     }
@@ -294,7 +294,7 @@ class AdaptFrameworkImport {
       this.statusReport.info.push({ code: 'MIGRATE_CONTENT', data })
     }
     await this.convertSchemas()
-    AdaptFrameworkUtils.log('debug', 'preparation tasks completed successfully')
+    FWUtils.log('debug', 'preparation tasks completed successfully')
   }
 
   /**
@@ -304,7 +304,7 @@ class AdaptFrameworkImport {
   async convertSchemas () {
     return octopus.runRecursive({
       cwd: this.unzipPath,
-      logger: { log: (...args) => AdaptFrameworkUtils.log('debug', ...args) }
+      logger: { log: (...args) => FWUtils.log('debug', ...args) }
     })
   }
 
@@ -319,11 +319,11 @@ class AdaptFrameworkImport {
     }
     try {
       const customStyle = await fs.readFile(customStylePath, 'utf8')
-      const courseJson = await fs.readJSON(courseJsonPath)
-      await fs.writeJSON(courseJsonPath, { customStyle, ...courseJson })
-      AdaptFrameworkUtils.log('info', 'patched course customStyle')
+      const courseJson = await FWUtils.readJson(courseJsonPath)
+      await FWUtils.writeJson(courseJsonPath, { customStyle, ...courseJson })
+      FWUtils.log('info', 'patched course customStyle')
     } catch (e) {
-      AdaptFrameworkUtils.log('warn', 'failed to patch course customStyle', e)
+      FWUtils.log('warn', 'failed to patch course customStyle', e)
     }
   }
 
@@ -333,12 +333,13 @@ class AdaptFrameworkImport {
   async patchThemeName () {
     const [configJsonPath] = await glob('**/config.json', { cwd: this.coursePath, absolute: true })
     try {
-      const configJson = await fs.readJSON(configJsonPath)
+      const configJson = await FWUtils.readJson(configJsonPath)
       if (configJson._theme) return
-      await fs.writeJSON(configJsonPath, { ...configJson, _theme: Object.values(this.usedContentPlugins).find(p => p.type === 'theme').name })
-      AdaptFrameworkUtils.log('info', 'patched config _theme')
+      configJson._theme = Object.values(this.usedContentPlugins).find(p => p.type === 'theme').name
+      await FWUtils.writeJson(configJsonPath, configJson)
+      FWUtils.log('info', 'patched config _theme')
     } catch (e) {
-      AdaptFrameworkUtils.log('warn', 'failed to patch config _theme', e)
+      FWUtils.log('warn', 'failed to patch config _theme', e)
     }
   }
 
@@ -350,14 +351,14 @@ class AdaptFrameworkImport {
     this.assetData = []
     const metaFiles = await glob(`${this.coursePath}/*/assets.json`, { absolute: true })
     if (metaFiles.length) { // process included asset metadata
-      AdaptFrameworkUtils.log('debug', 'processing metadata files', metaFiles)
+      FWUtils.log('debug', 'processing metadata files', metaFiles)
       await Promise.all(metaFiles.map(async f => {
-        const metaJson = await fs.readJson(f)
+        const metaJson = await FWUtils.readJson(f)
         Object.entries(metaJson).forEach(([filename, metadata]) => this.assetData.push({ filename, ...metadata }))
       }))
     } else { // process the file metadata manually
       const assetFiles = await glob(`${this.coursePath}/*/*/*`, { absolute: true })
-      AdaptFrameworkUtils.log('debug', 'processing asset files manually', assetFiles.length)
+      FWUtils.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
@@ -380,9 +381,9 @@ class AdaptFrameworkImport {
       }
     }
     await Promise.all(usedPluginPaths.map(async p => {
-      const bowerJson = await fs.readJson(`${p}/bower.json`)
+      const bowerJson = await FWUtils.readJson(`${p}/bower.json`)
       const { name, version, targetAttribute } = bowerJson
-      AdaptFrameworkUtils.log('debug', 'found plugin', name)
+      FWUtils.log('debug', 'found plugin', name)
       this.usedContentPlugins[path.basename(p)] = { name, path: p, version, targetAttribute, type: getPluginType(bowerJson) }
     }))
   }
@@ -394,8 +395,8 @@ class AdaptFrameworkImport {
   async loadCourseData () {
     const files = await glob('**/*.json', { cwd: this.coursePath, 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: AdaptFrameworkUtils.getImportContentCounts(this.contentJson) })
-    AdaptFrameworkUtils.log('info', 'loaded course data successfully')
+    this.statusReport.info.push({ code: 'CONTENT_IMPORTED', data: FWUtils.getImportContentCounts(this.contentJson) })
+    FWUtils.log('info', 'loaded course data successfully')
     return mapped
   }
 
@@ -404,7 +405,7 @@ class AdaptFrameworkImport {
    * @return {Promise}
    */
   async loadContentFile (filePath) {
-    const contents = await fs.readJson(filePath)
+    const contents = await FWUtils.readJson(filePath)
     if (contents._type === 'course') {
       this.contentJson.course = contents
       return
@@ -422,12 +423,12 @@ class AdaptFrameworkImport {
       contents.forEach(c => {
         this.contentJson.contentObjects[c._id] = c
         if (!c._type) {
-          AdaptFrameworkUtils.log('warn', App.instance.errors.FW_IMPORT_INVALID_CONTENT.setData({ item: c }))
+          FWUtils.log('warn', App.instance.errors.FW_IMPORT_INVALID_CONTENT.setData({ item: c }))
           this.statusReport.warn.push({ code: 'INVALID_CONTENT', data: c })
         }
       })
     }
-    AdaptFrameworkUtils.log('debug', 'LOAD_CONTENT', path.resolve(filePath))
+    FWUtils.log('debug', 'LOAD_CONTENT', path.resolve(filePath))
   }
 
   /**
@@ -435,7 +436,7 @@ class AdaptFrameworkImport {
    * @return {Promise}
    */
   async runGruntTask (subTask, { outputDir, captureDir, outputFilePath }) {
-    const output = await AdaptFrameworkUtils.spawnPromise('npx', ['grunt', `migration:${subTask}`, `--outputdir=${outputDir}`, `--capturedir=${captureDir}`])
+    const output = await FWUtils.spawnPromise('npx', ['grunt', `migration:${subTask}`, `--outputdir=${outputDir}`, `--capturedir=${captureDir}`])
     if (outputFilePath) await fs.writeFile(outputFilePath, output)
   }
 
@@ -449,22 +450,22 @@ class AdaptFrameworkImport {
 
       const folderName = `${this.userId}-migrations`
       const relativePath = path.relative(this.framework.path, this.unzipPath)
-      const outputDir = fs.existsSync(path.join(this.unzipPath, 'build'))
+      const outputDir = await FWUtils.exists(path.join(this.unzipPath, 'build'))
         ? path.join(relativePath, 'build')
         : path.join(relativePath, 'src')
       const captureDir = path.join('./', folderName)
 
-      AdaptFrameworkUtils.logDir('captureDir', path.join(this.framework.path, captureDir))
-      AdaptFrameworkUtils.logDir('outputDir', path.join(this.unzipPath, outputDir))
+      FWUtils.logDir('captureDir', path.join(this.framework.path, captureDir))
+      FWUtils.logDir('outputDir', path.join(this.unzipPath, outputDir))
 
       const opts = { outputDir, captureDir, outputFilePath: path.join(this.framework.path, 'migrations', `${this.userId}.txt`) }
       await this.runGruntTask('capture', opts)
       await this.runGruntTask('migrate', opts)
 
       const captureFolder = path.join(this.framework.path, captureDir)
-      await fs.remove(captureFolder)
+      await fs.rm(captureFolder, { recursive: true })
     } catch (error) {
-      AdaptFrameworkUtils.log('error', 'Migration process failed', error)
+      FWUtils.log('error', 'Migration process failed', error)
       throw new Error(`Migration process failed: ${error.message}`)
     }
   }
@@ -505,7 +506,7 @@ class AdaptFrameworkImport {
     if (course.tags) {
       course.tags = course.tags.map(t => existingTagMap[t])
     }
-    AdaptFrameworkUtils.log('debug', 'imported tags successfully')
+    FWUtils.log('debug', 'imported tags successfully')
   }
 
   /**
@@ -539,7 +540,7 @@ class AdaptFrameworkImport {
       }
       imagesImported++
     }))
-    AdaptFrameworkUtils.log('debug', 'imported course assets successfully')
+    FWUtils.log('debug', 'imported course assets successfully')
     this.statusReport.info.push({ code: 'ASSETS_IMPORTED_SUCCESSFULLY', data: { count: imagesImported } })
   }
 
@@ -571,7 +572,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 } })
-        AdaptFrameworkUtils.log('debug', `migrating '${p}@${importVersion}' during import, installed version is newer (${installedVersion})`)
+        FWUtils.log('debug', `migrating '${p}@${importVersion}' during import, installed version is newer (${installedVersion})`)
         this.pluginsToMigrate.push(p)
         return
       }
@@ -580,12 +581,12 @@ class AdaptFrameworkImport {
       }
       if (semver.eq(importVersion, installedVersion)) {
         this.statusReport.info.push({ code: 'PLUGIN_INSTALL_NOT_NEWER', data: { name: p, installedVersion, importVersion } })
-        AdaptFrameworkUtils.log('debug', `not updating '${p}@${importVersion}' during import, installed version is equal to (${installedVersion})`)
+        FWUtils.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 } })
-        AdaptFrameworkUtils.log('debug', `cannot update '${p}' during import, plugin managed via UI`)
+        FWUtils.log('debug', `cannot update '${p}' during import, plugin managed via UI`)
       }
       pluginsToUpdate.push(p)
     })
@@ -600,10 +601,10 @@ class AdaptFrameworkImport {
         try {
           // try and infer a targetAttribute if there isn't one
           const pluginBowerPath = path.join(this.usedContentPlugins[p].path, 'bower.json')
-          const bowerJson = await fs.readJson(pluginBowerPath)
+          const bowerJson = await FWUtils.readJson(pluginBowerPath)
           if (!bowerJson.targetAttribute) {
             bowerJson.targetAttribute = `_${bowerJson.component || bowerJson.extension || bowerJson.menu || bowerJson.theme}`
-            await fs.writeJson(pluginBowerPath, bowerJson, { spaces: 2 })
+            await FWUtils.writeJson(pluginBowerPath, bowerJson)
           }
           if (!this.settings.isDryRun) {
             const [pluginData] = await this.contentplugin.installPlugins([[p, this.usedContentPlugins[p].path]], { strict: true })
@@ -612,7 +613,7 @@ class AdaptFrameworkImport {
           this.statusReport.info.push({ code: 'INSTALL_PLUGIN', data: { name: p, version: bowerJson.version } })
         } catch (e) {
           if (e.code !== 'EEXIST') {
-            AdaptFrameworkUtils.log('error', 'PLUGIN_IMPORT_FAILED', p, e)
+            FWUtils.log('error', 'PLUGIN_IMPORT_FAILED', p, e)
             errors.push({ plugin: p, error: e.data.errors[0] })
           } else {
             errors.push(e)
@@ -627,7 +628,7 @@ class AdaptFrameworkImport {
     this.componentNameMap = Object.values({ ...this.installedPlugins, ...this.newContentPlugins }).reduce((m, v) => {
       return { ...m, [v.targetAttribute.slice(1)]: v.name }
     }, {})
-    AdaptFrameworkUtils.log('debug', 'imported course plugins successfully')
+    FWUtils.log('debug', 'imported course plugins successfully')
   }
 
   /**
@@ -665,7 +666,7 @@ class AdaptFrameworkImport {
       }
     }
     if (errors.length) throw App.instance.errors.FW_IMPORT_CONTENT_FAILED.setData({ errors: errors.join('; ') })
-    AdaptFrameworkUtils.log('debug', 'imported course data successfully')
+    FWUtils.log('debug', 'imported course data successfully')
   }
 
   /**
@@ -711,7 +712,7 @@ class AdaptFrameworkImport {
     try {
       this.extractAssets(schema.built.properties, insertData)
     } catch (e) {
-      AdaptFrameworkUtils.log('error', `failed to extract asset data for attribute '${e.attribute}' of schema '${schemaName}', ${e}`)
+      FWUtils.log('error', `failed to extract asset data for attribute '${e.attribute}' of schema '${schemaName}', ${e}`)
     }
     insertData = await schema.sanitise(insertData)
     let doc
@@ -770,7 +771,7 @@ class AdaptFrameworkImport {
   async cleanUp (error) {
     try {
       const tasks = [
-        fs.remove(this.unzipPath)
+        fs.rm(this.unzipPath, { recursive: true })
       ]
       if (error) {
         tasks.push(

package/lib/AdaptFrameworkModule.js

@@ -105,13 +105,13 @@ class AdaptFrameworkModule extends AbstractModule {
       const modsPath = path.resolve(this.path, '..', 'node_modules')
       try {
         await fs.stat(modsPath)
-        await fs.readJson(path.resolve(this.path, 'package.json'))
+        await fs.readFile(path.resolve(this.path, 'package.json'))
         if (!force) {
           this.log('verbose', 'INSTALL no action, force !== true')
           return
         }
         this.log('verbose', 'INSTALL forcing new framework install')
-        await fs.remove(this.path)
+        await fs.rm(this.path, { recursive: true })
       } catch (e) {
         // if src and node_modules are missing, install required
       }
@@ -119,10 +119,10 @@ class AdaptFrameworkModule extends AbstractModule {
       // move node_modules into place
       this.log('verbose', 'INSTALL node_modules')
       try {
-        await fs.remove(modsPath)
+        await fs.rm(modsPath, { recursive: true })
       } catch (e) {}
       // move node_modules so it can be shared with all builds
-      await fs.move(path.join(this.path, 'node_modules'), modsPath)
+      await fs.rename(path.join(this.path, 'node_modules'), modsPath)
     } catch (e) {
       this.log('error', `failed to install framework, ${e.message}`)
       throw this.app.errors.FW_INSTALL_FAILED
@@ -149,7 +149,7 @@ class AdaptFrameworkModule extends AbstractModule {
    * @return {Promise}
    */
   async getManifestPlugins () {
-    const manifest = await fs.readJson(path.resolve(this.path, 'adapt.json'))
+    const manifest = await FWUtils.readJson(path.resolve(this.path, 'adapt.json'))
     return Object.entries(manifest.dependencies)
   }
 

package/lib/AdaptFrameworkUtils.js

@@ -3,7 +3,8 @@ import { App } from 'adapt-authoring-core'
 import bytes from 'bytes'
 import FrameworkBuild from './AdaptFrameworkBuild.js'
 import FrameworkImport from './AdaptFrameworkImport.js'
-import fs from 'fs'
+import fs from 'fs/promises'
+/* eslint-disable import/no-named-default */import { default as fsSync } from 'fs'
 import path from 'upath'
 import semver from 'semver'
 import { spawn } from 'child_process'
@@ -51,7 +52,7 @@ class AdaptFrameworkUtils {
     try {
       const resolved = dir ? path.resolve(dir) : undefined
       AdaptFrameworkUtils.log('verbose', 'DIR', label, resolved)
-      if (resolved) AdaptFrameworkUtils.log('verbose', 'DIR_MODE', label, fs.statSync(resolved).mode)
+      if (resolved) AdaptFrameworkUtils.log('verbose', 'DIR_MODE', label, fsSync.statSync(resolved).mode)
     } catch (e) {
       AdaptFrameworkUtils.log('warn', `failed to log dir ${label} (${dir}), ${e.code}`)
     }
@@ -61,6 +62,26 @@ class AdaptFrameworkUtils {
     AdaptFrameworkUtils.log('verbose', 'MEMORY', Object.entries(process.memoryUsage()).reduce((m, [k, v]) => Object.assign(m, { [k]: bytes.parse(v) }), {}))
   }
 
+  static async readJson (filepath) {
+    return JSON.parse(await fs.readFile(filepath))
+  }
+
+  static writeJson (filepath, data) {
+    return fs.writeFile(filepath, (JSON.stringify(data, null, 2)))
+  }
+
+  static async exists (filepath) {
+    try {
+      await fs.stat(filepath)
+      return true
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        return false
+      }
+      throw e
+    }
+  }
+
   /**
    * Infers the framework action to be executed from a given request URL
    * @param {external:ExpressRequest} req
@@ -220,11 +241,11 @@ class AdaptFrameworkUtils {
       }
       const filePath = path.resolve(buildData.location, req.path.slice(req.path.indexOf(id) + id.length + 1) || 'index.html')
       try {
-        await fs.promises.stat(filePath)
-        res.sendFile(filePath)
+        await AdaptFrameworkUtils.exists(filePath)
+          ? res.sendFile(filePath)
+          : next(App.instance.errors.NOT_FOUND.setData({ type: 'file', id: filePath }))
       } catch (e) {
-        if (e.code === 'ENOENT') return next(App.instance.errors.NOT_FOUND.setData({ type: 'file', id: filePath }))
-        return next(e)
+        if (e.code === 'ENOENT') return next(e)
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Adapt framework integration for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-adaptframework",
   "license": "GPL-3.0",