adapt-authoring-contentplugin 1.0.9 → 1.1.0

package/lib/ContentPluginModule.js

@@ -187,9 +187,32 @@ class ContentPluginModule extends AbstractApiModule {
       return (await this.framework.getManifestPlugins()).map(([name, version]) => `${name}@${version}`)
     }
     const fwPlugins = await this.framework.getInstalledPlugins()
-    return dbPlugins
-      .filter(dbP => !fwPlugins.find(fwP => dbP.name === fwP.name))
-      .map(p => `${p.name}@${p.isLocalInstall ? path.join(this.getConfig('pluginDir'), p.name) : p.version}`)
+    const missingPlugins = dbPlugins.filter(dbP => !fwPlugins.find(fwP => dbP.name === fwP.name))
+    // For local installs, check if backup exists if main plugin directory doesn't
+    const pluginsWithPaths = await Promise.all(missingPlugins.map(async (p) => {
+      if (!p.isLocalInstall) {
+        return `${p.name}@${p.version}`
+      }
+      const pluginDir = this.getConfig('pluginDir')
+      const pluginPath = path.join(pluginDir, p.name)
+      // Check if the main plugin directory exists
+      try {
+        await fs.access(pluginPath)
+        return `${p.name}@${pluginPath}`
+      } catch (e) {
+        // Check for backups
+        if (e.code && e.code !== 'ENOENT' && e.code !== 'ENOTDIR') {
+          this.log('warn', `Unexpected error accessing ${pluginPath}: ${e.code}`)
+        }
+        const mostRecentBackup = await this.getMostRecentBackup(pluginDir, p.name)
+        if (mostRecentBackup) {
+          return `${p.name}@${mostRecentBackup}`
+        }
+        // No backup found, return the standard path (will likely fail, but consistent with original behavior)
+        return `${p.name}@${pluginPath}`
+      }
+    }))
+    return pluginsWithPaths
   }
 
   /**
@@ -330,6 +353,134 @@ class ContentPluginModule extends AbstractApiModule {
     return info
   }
 
+  /**
+   * Creates a backup of an existing plugin directory with version information
+   * @param {String} pluginPath Path to the plugin directory
+   * @param {String} pluginName Name of the plugin
+   * @returns {Promise<String|null>} Path to the backup directory, or null if no backup was created
+   */
+  async backupPluginVersion (pluginPath, pluginName) {
+    try {
+      await fs.access(pluginPath)
+    } catch (e) { // No plugin, no backup needed
+      return null
+    }
+    let existingVersion
+    try {
+      const pkgPath = path.join(pluginPath, 'package.json')
+      const pkg = await this.readJson(pkgPath)
+      existingVersion = pkg.version
+    } catch (e) {
+      try {
+        const bowerPath = path.join(pluginPath, 'bower.json')
+        const bower = await this.readJson(bowerPath)
+        existingVersion = bower.version
+      } catch (e2) {
+        this.log('warn', `Could not read version for backup of ${pluginName}`)
+        existingVersion = `unknown-${Date.now()}`
+      }
+    }
+    const backupDir = `${pluginPath}-v${existingVersion}`
+    await fs.rename(pluginPath, backupDir)
+    this.log('info', `Backed up ${pluginName}@${existingVersion}`)
+    return backupDir
+  }
+
+  /**
+   * Gets the most recent backup for a plugin based on version sorting
+   * @param {String} pluginDir Base directory containing plugins
+   * @param {String} pluginName Name of the plugin
+   * @returns {Promise<String|null>} Path to the most recent backup, or null if none found
+   */
+  async getMostRecentBackup (pluginDir, pluginName) {
+    const pattern = `${pluginName}-v*`
+    const backups = await glob(pattern, { cwd: pluginDir, absolute: true })
+
+    if (backups.length === 0) {
+      return null
+    }
+
+    // Sort by version (newest first)
+    // Extract version from backup path (format: pluginName-vX.Y.Z)
+    backups.sort((a, b) => {
+      const versionA = path.basename(a).replace(`${pluginName}-v`, '')
+      const versionB = path.basename(b).replace(`${pluginName}-v`, '')
+
+      // Try to compare as semver versions
+      if (semver.valid(versionA) && semver.valid(versionB)) {
+        return semver.rcompare(versionA, versionB) // descending order
+      }
+
+      // Fall back to alphabetical comparison for non-semver versions (e.g., unknown-timestamp)
+      return b.localeCompare(a)
+    })
+
+    return backups[0]
+  }
+
+  /**
+   * Cleans up old plugin version backups, keeping only the most recent one
+   * @param {String} pluginDir Base directory containing plugins
+   * @param {String} pluginName Name of the plugin
+   * @returns {Promise<void>}
+   */
+  async cleanupOldPluginBackups (pluginDir, pluginName) {
+    const pattern = `${pluginName}-v*`
+    const backups = await glob(pattern, { cwd: pluginDir, absolute: true })
+
+    if (backups.length <= 1) {
+      return
+    }
+
+    // Get the most recent backup using the helper
+    const mostRecent = await this.getMostRecentBackup(pluginDir, pluginName)
+
+    // Remove all backups except the most recent
+    const backupsToRemove = backups.filter(backup => backup !== mostRecent)
+    for (const backup of backupsToRemove) {
+      await fs.rm(backup, { recursive: true })
+      this.log('info', `Removed old backup: ${backup}`)
+    }
+  }
+
+  /**
+   * Restores a plugin from the most recent backup
+   * @param {String} pluginName Name of the plugin to restore
+   * @returns {Promise<Object>} Resolves with restored plugin info
+   */
+  async restorePluginFromBackup (pluginName) {
+    const pluginDir = this.getConfig('pluginDir')
+    const pluginPath = path.join(pluginDir, pluginName)
+    const mostRecentBackup = await this.getMostRecentBackup(pluginDir, pluginName)
+
+    if (!mostRecentBackup) {
+      throw this.app.errors.NOT_FOUND
+        .setData({ type: 'backup', id: pluginName })
+    }
+    // Remove current version if it exists
+    try {
+      await fs.access(pluginPath)
+      await fs.rm(pluginPath, { recursive: true })
+    } catch (e) {
+      // Current version doesn't exist, that's fine
+    }
+    // Restore the backup
+    await fs.rename(mostRecentBackup, pluginPath)
+    this.log('info', `Restored ${pluginName} from backup`)
+    let pkg
+    try {
+      pkg = await this.readJson(path.join(pluginPath, 'package.json'))
+    } catch (e) {
+      try {
+        pkg = await this.readJson(path.join(pluginPath, 'bower.json'))
+      } catch (e2) {
+        throw this.app.errors.CONTENTPLUGIN_INVALID_ZIP
+          .setData({ pluginName, message: 'Could not read package.json or bower.json from backup' })
+      }
+    }
+    return pkg
+  }
+
   /**
    * Ensures local plugin source files are stored in the correct location and structured in an expected way
    * @param {Object} pluginData Plugin metadata
@@ -357,6 +508,15 @@ class ContentPluginModule extends AbstractApiModule {
     } catch (e) {
       throw this.app.errors.CONTENTPLUGIN_INVALID_ZIP
     }
+
+    const pluginDir = this.getConfig('pluginDir')
+
+    // Back up the existing version if it exists
+    await this.backupPluginVersion(pkg.sourcePath, pkg.name)
+
+    // Clean up old backups (keep only 1 previous version)
+    await this.cleanupOldPluginBackups(pluginDir, pkg.name)
+
     // move the files into the persistent location
     await fs.cp(sourcePath, pkg.sourcePath, { recursive: true })
     await fs.rm(sourcePath, { recursive: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-contentplugin",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Module for managing framework plugins",
   "homepage": "https://github.com/adapt-security/adapt-authoring-contentplugin",
   "repository": "github:adapt-security/adapt-authoring-contentplugin",