adapt-cli 2.1.13 → 3.0.0

package/lib/integration/PluginManagement/print.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk'
+import semver from 'semver'
+import { ADAPT_ALLOW_PRERELEASE } from '../../util/constants.js'
+const semverOptions = { includePrerelease: ADAPT_ALLOW_PRERELEASE }
+
+function highlight (pluginname) {
+  return ['adapt-contrib', 'adapt-'].reduce((output, prefix) => {
+    if (output || !pluginname.startsWith(prefix)) return output
+    return chalk.reset(prefix) + chalk.yellowBright(pluginname.substring(prefix.length))
+  }, null) || pluginname
+}
+
+function greenIfEqual (v1, v2) {
+  if (v1 === '*') return chalk.greenBright(v2)
+  return semver.satisfies(v1, v2, semverOptions)
+    ? chalk.greenBright(v2)
+    : chalk.magentaBright(v2)
+}
+
+export function versionPrinter (plugin, logger) {
+  const {
+    versionToApply,
+    latestCompatibleSourceVersion
+  } = plugin
+  logger?.log(highlight(plugin.packageName), latestCompatibleSourceVersion === null
+    ? '(no version information)'
+    : `${chalk.greenBright(versionToApply)}${plugin.isLocalSource ? ' (local)' : ` (latest compatible version is ${greenIfEqual(versionToApply, latestCompatibleSourceVersion)})`}`
+  )
+}
+
+export function existingVersionPrinter (plugin, logger) {
+  const {
+    preUpdateProjectVersion,
+    projectVersion,
+    latestCompatibleSourceVersion
+  } = plugin
+  const fromTo = preUpdateProjectVersion !== null
+    ? `from ${chalk.greenBright(preUpdateProjectVersion)} to ${chalk.greenBright(projectVersion)}`
+    : `${chalk.greenBright(projectVersion)}`
+  logger?.log(highlight(plugin.packageName), latestCompatibleSourceVersion === null
+    ? fromTo
+    : `${fromTo}${plugin.isLocalSource ? ' (local)' : ` (latest compatible version is ${greenIfEqual(projectVersion, latestCompatibleSourceVersion)})`}`
+  )
+}
+
+export function errorPrinter (plugin, logger) {
+  logger?.log(highlight(plugin.packageName), plugin.installError ? '(error: ' + plugin.installError + ')' : '(unknown error)')
+}
+
+export function packageNamePrinter (plugin, logger) {
+  logger?.log(highlight(plugin.packageName))
+}

package/lib/integration/PluginManagement/register.js

@@ -0,0 +1,130 @@
+
+import getBowerRegistryConfig from '../getBowerRegistryConfig.js'
+import fs from 'fs-extra'
+import path from 'path'
+import bower from 'bower'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { readValidateJSON } from '../../util/JSONReadValidate.js'
+import Plugin from '../Plugin.js'
+import semver from 'semver'
+import { ADAPT_ALLOW_PRERELEASE } from '../../util/constants.js'
+const semverOptions = { includePrerelease: ADAPT_ALLOW_PRERELEASE }
+
+export default async function register ({
+  logger,
+  cwd = process.cwd()
+} = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd })
+  logger?.warn('Using registry at', BOWER_REGISTRY_CONFIG.register)
+  try {
+    const bowerJSONPath = path.join(cwd, 'bower.json')
+    const hasBowerJSON = fs.existsSync(bowerJSONPath)
+
+    const bowerJSON = {
+      name: undefined,
+      repository: undefined,
+      framework: undefined,
+      ...(hasBowerJSON ? await readValidateJSON(bowerJSONPath) : {})
+    }
+    const properties = await confirm(bowerJSON)
+    hasBowerJSON && await fs.writeJSON(bowerJSONPath, properties, { spaces: 2, replacer: null })
+
+    // given a package name, create two Plugin representations
+    // if supplied name is adapt-contrib-myPackageName do a check against this name only
+    // if suppled name is adapt-myPackageName check against this name and adapt-contrib-myPackageName
+    // becase we don't want to allow adapt-myPackageName if adapt-contrib-myPackageName exists
+    const plugin = new Plugin({ name: properties.name, logger })
+    const contribPlugin = new Plugin({ name: properties.name, isContrib: true, logger })
+    const contribExists = await exists(BOWER_REGISTRY_CONFIG, contribPlugin)
+    const pluginExists = await exists(BOWER_REGISTRY_CONFIG, plugin)
+
+    if (contribExists || pluginExists) {
+      logger?.warn(plugin.toString(), 'has been previously registered. Plugin names must be unique. Try again with a different name.')
+      return
+    }
+
+    const result = await registerWithBowerRepo(BOWER_REGISTRY_CONFIG, plugin, properties.repository)
+    if (!result) throw new Error('The plugin was unable to register.')
+    logger?.log(chalk.green(plugin.packageName), 'has been registered successfully.')
+  } catch (err) {
+    logger?.error(err)
+  }
+}
+
+async function confirm (properties) {
+  const plugin = new Plugin({ name: properties.name })
+  const schema = [
+    {
+      name: 'name',
+      message: chalk.cyan('name'),
+      validate: v => {
+        return /^adapt-[\w|-]+?$/.test(v) ||
+            'Name must prefixed with \'adapt\' and each word separated with a hyphen(-)'
+      },
+      type: 'input',
+      default: plugin.toString() || 'not specified'
+    },
+    {
+      name: 'repositoryUrl',
+      message: chalk.cyan('repository URL'),
+      validate: v => {
+        return /https:\/\/([\w.@:/\-~]+)(\.git)(\/)?/.test(v) ||
+            'Please provide a repository URL of the form https://<domain><path>.git'
+      },
+      type: 'input',
+      default: properties.repository ? properties.repository.url : undefined
+    },
+    {
+      name: 'framework',
+      message: chalk.cyan('framework'),
+      validate: v => {
+        return semver.validRange(v, semverOptions) !== null ||
+            'Please provide a valid semver (see https://semver.org/)'
+      },
+      type: 'input',
+      default: properties.framework || '>=5.15'
+    },
+    {
+      name: 'ready',
+      message: chalk.cyan('Register now?'),
+      type: 'confirm',
+      default: true
+    }
+  ]
+  const confirmation = await inquirer.prompt(schema)
+  if (!confirmation.ready) throw new Error('Aborted. Nothing has been registered.')
+  properties.name = confirmation.name
+  properties.repository = { type: 'git', url: confirmation.repositoryUrl }
+  properties.framework = confirmation.framework
+  return properties
+}
+
+/**
+ * @param {Plugin} plugin
+ * @returns {boolean}
+ */
+async function exists (BOWER_REGISTRY_CONFIG, plugin) {
+  const pluginName = plugin.toString().toLowerCase()
+  return new Promise((resolve, reject) => {
+    bower.commands.search(pluginName, {
+      registry: BOWER_REGISTRY_CONFIG.register
+    })
+      .on('end', result => {
+        const matches = result.filter(({ name }) => name.toLowerCase() === pluginName)
+        resolve(Boolean(matches.length))
+      })
+      .on('error', reject)
+  })
+}
+
+async function registerWithBowerRepo (BOWER_REGISTRY_CONFIG, plugin, repository) {
+  return new Promise((resolve, reject) => {
+    bower.commands.register(plugin.toString(), repository.url || repository, {
+      registry: BOWER_REGISTRY_CONFIG
+    })
+      .on('end', resolve)
+      .on('error', reject)
+  })
+}

package/lib/integration/PluginManagement/rename.js

@@ -0,0 +1,101 @@
+import getBowerRegistryConfig from '../getBowerRegistryConfig.js'
+import authenticate from './autenticate.js'
+import bower from 'bower'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import request from 'request'
+import path from 'path'
+import Plugin from '../Plugin.js'
+
+export default async function rename ({
+  logger,
+  oldName,
+  newName,
+  cwd = process.cwd()
+} = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd })
+  if (!oldName || !newName) {
+    logger?.error('You must call rename with the following arguments: <plugin name> <new plugin name>')
+    return
+  }
+  // use Plugin to standardise name
+  newName = new Plugin({ name: newName, logger }).packageName
+  oldName = new Plugin({ name: oldName, logger }).packageName
+  logger?.warn('Using registry at', BOWER_REGISTRY_CONFIG.register)
+  logger?.warn(`Plugin will be renamed from ${oldName} to ${newName}`)
+  try {
+    const oldExists = await exists(BOWER_REGISTRY_CONFIG, oldName)
+    if (!oldExists) throw new Error(`Plugin "${oldName}" does not exist`)
+    const newExists = await exists(BOWER_REGISTRY_CONFIG, newName)
+    if (newExists) throw new Error(`Name "${newName}" already exists`)
+    const { username, token, type } = await authenticate({ pluginName: oldName })
+    logger?.log(`${username} authenticated as ${type}`)
+    await confirm()
+    await renameInBowerRepo({
+      username,
+      token,
+      oldName,
+      newName,
+      BOWER_REGISTRY_CONFIG
+    })
+    logger?.log(chalk.green('The plugin was successfully renamed.'))
+  } catch (err) {
+    logger?.error(err)
+    logger?.error('The plugin was not renamed.')
+  }
+}
+
+async function confirm () {
+  const schema = [
+    {
+      name: 'ready',
+      message: chalk.cyan('Confirm rename now?'),
+      type: 'confirm',
+      default: true
+    }
+  ]
+  const confirmation = await inquirer.prompt(schema)
+  if (!confirmation.ready) throw new Error('Aborted. Nothing has been renamed.')
+}
+
+async function renameInBowerRepo ({
+  username,
+  token,
+  oldName,
+  newName,
+  BOWER_REGISTRY_CONFIG
+}) {
+  const path = 'packages/rename/' + username + '/' + oldName + '/' + newName
+  const query = '?access_token=' + token
+  return new Promise((resolve, reject) => {
+    request({
+      url: BOWER_REGISTRY_CONFIG.register + path + query,
+      method: 'GET',
+      headers: { 'User-Agent': 'adapt-cli' },
+      followRedirect: false
+    }, (err, res) => {
+      if (err) return reject(err)
+      if (res.statusCode !== 201) reject(new Error(`The server responded with ${res.statusCode}`))
+      resolve()
+    })
+  })
+}
+
+/**
+ * @param {Plugin} plugin
+ * @returns {boolean}
+ */
+async function exists (BOWER_REGISTRY_CONFIG, plugin) {
+  const pluginName = plugin.toString().toLowerCase()
+  return new Promise((resolve, reject) => {
+    bower.commands.search(pluginName, {
+      registry: BOWER_REGISTRY_CONFIG.register
+    })
+      .on('end', result => {
+        const matches = result.filter(({ name }) => name.toLowerCase() === pluginName)
+        resolve(Boolean(matches.length))
+      })
+      .on('error', reject)
+  })
+}

package/lib/integration/PluginManagement/schemas.js

@@ -0,0 +1,8 @@
+import Project from '../Project.js'
+import path from 'path'
+
+export default async function schemas ({ cwd = process.cwd() } = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const project = new Project({ cwd })
+  return await project.getSchemaPaths({ cwd })
+}

package/lib/integration/PluginManagement/search.js

@@ -0,0 +1,46 @@
+import getBowerRegistryConfig from '../getBowerRegistryConfig.js'
+import chalk from 'chalk'
+import request from 'request'
+import path from 'path'
+
+export default async function search ({
+  logger,
+  searchTerm,
+  cwd = process.cwd()
+} = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd })
+  try {
+    const uniqueResults = {}
+    for (const serverURI of BOWER_REGISTRY_CONFIG.search) {
+      try {
+        const immediateResults = await new Promise((resolve, reject) => {
+          request({
+            uri: `${serverURI}packages/search/${searchTerm}`,
+            method: 'GET',
+            headers: { 'User-Agent': 'adapt-cli' },
+            followRedirect: false
+          }, (err, res, body) => {
+            if (err) return reject(err)
+            if (res.statusCode !== 200) reject(new Error(`The server responded with ${res.statusCode}`))
+            try {
+              resolve(JSON.parse(body))
+            } catch (err) {
+              reject(err)
+            }
+          })
+        })
+        immediateResults?.forEach(result => (uniqueResults[result.name] = uniqueResults[result.name] ?? result))
+      } catch (err) {}
+    }
+    const results = Object.values(uniqueResults)
+    if (!results.length) {
+      logger?.warn(`no plugins found containing: ${searchTerm}`)
+    }
+    results.forEach(function (result) {
+      logger?.log(chalk.cyan(result.name) + ' ' + result.url)
+    })
+  } catch (err) {
+    logger?.error("Oh dear, something went wrong. I'm terribly sorry.", err)
+  }
+}

package/lib/integration/PluginManagement/uninstall.js

@@ -0,0 +1,141 @@
+
+import chalk from 'chalk'
+import Project from '../Project.js'
+import Target from '../Target.js'
+import { eachOfLimitProgress } from '../../util/promises.js'
+import { createPromptTask } from '../../util/createPromptTask.js'
+import { errorPrinter, packageNamePrinter } from './print.js'
+import { intersection } from 'lodash-es'
+import path from 'path'
+
+export default async function uninstall ({
+  plugins,
+  isInteractive = true,
+  cwd = process.cwd(),
+  logger = null
+}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const project = new Project({ cwd, logger })
+  project.tryThrowInvalidPath()
+
+  logger?.log(chalk.cyan('uninstalling adapt dependencies...'))
+
+  const targets = await getUninstallTargets({ logger, project, plugins, isInteractive })
+  if (!targets?.length) return targets
+
+  await loadPluginData({ logger, targets })
+  await eachOfLimitProgress(
+    targets.filter(target => target.isToBeUninstalled),
+    target => target.uninstall(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Uninstalling plugins ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Uninstalling plugins 100% complete`)
+  const installedDependencies = await project.getInstalledDependencies()
+  await updateManifest({ project, targets, installedDependencies, isInteractive })
+  await summariseUninstallation({ logger, targets })
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ */
+async function getUninstallTargets ({ logger, project, plugins, isInteractive }) {
+  if (typeof plugins === 'string') plugins = [plugins]
+  /** whether adapt.json is being used to compile the list of targets to install */
+  const isEmpty = !plugins?.length
+  if (isEmpty && isInteractive) {
+    const shouldContinue = await createPromptTask({
+      message: chalk.reset('This command will attempt to uninstall all installed plugins. Do you wish to continue?'),
+      type: 'confirm'
+    })
+    if (!shouldContinue) return
+  }
+
+  /** a list of plugin name/version pairs */
+  const itinerary = isEmpty
+    ? await project.getInstalledDependencies()
+    : plugins.reduce((itinerary, arg) => {
+      const [name, version = '*'] = arg.split(/[#@]/)
+      // Duplicates are removed by assigning to object properties
+      itinerary[name] = version
+      return itinerary
+    }, {})
+  const pluginNames = Object.entries(itinerary).map(([name, version]) => `${name}@${version}`)
+
+  /** @type {[Target]} */
+  const targets = pluginNames
+    ? pluginNames.map(nameVersion => {
+      const [name] = nameVersion.split(/[#@]/)
+      return new Target({ name, project, logger })
+    })
+    : await project.getUninstallTargets()
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ */
+async function loadPluginData ({ logger, targets }) {
+  await eachOfLimitProgress(
+    targets,
+    target => target.fetchProjectInfo(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Getting plugin info ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Getting plugin info 100% complete`)
+  await eachOfLimitProgress(
+    targets,
+    target => target.markUninstallable(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Marking uninstallable ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Marking uninstallable 100% complete`)
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ * @returns
+ */
+async function updateManifest ({ project, targets, installedDependencies, isInteractive }) {
+  if (targets.filter(target => target.isToBeUninstalled).length === 0) return
+  if (intersection(Object.keys(installedDependencies), targets.map(target => target.packageName)).length) return
+  if (isInteractive) {
+    const shouldUpdate = await createPromptTask({
+      message: chalk.white('Update the manifest (adapt.json)?'),
+      type: 'confirm',
+      default: true
+    })
+    if (!shouldUpdate) return
+  }
+  targets.forEach(target => target.isToBeUninstalled && project.remove(target))
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+function summariseUninstallation ({ logger, targets }) {
+  const uninstallSucceeded = targets.filter(target => target.isUninstallSuccessful)
+  const uninstallSkipped = targets.filter(target => !target.isToBeUninstalled || target.isSkipped)
+  const uninstallErrored = targets.filter(target => target.isUninstallFailure)
+  const missing = targets.filter(target => target.isMissing)
+  const noneUninstalled = (uninstallSucceeded.length === 0)
+  const allUninstalledSuccessfully = (uninstallErrored.length === 0 && missing.length === 0)
+  const someUninstalledSuccessfully = (!noneUninstalled && !allUninstalledSuccessfully)
+  summarise(logger, uninstallSkipped, packageNamePrinter, 'The following plugins were skipped:')
+  summarise(logger, missing, packageNamePrinter, 'There was a problem locating the following plugins:')
+  summarise(logger, uninstallErrored, errorPrinter, 'The following plugins could not be uninstalled:')
+  if (noneUninstalled) logger?.log(chalk.cyanBright('None of the requested plugins could be uninstalled'))
+  else if (allUninstalledSuccessfully) summarise(logger, uninstallSucceeded, packageNamePrinter, 'All requested plugins were successfully uninstalled. Summary of uninstallation:')
+  else if (someUninstalledSuccessfully) summarise(logger, uninstallSucceeded, packageNamePrinter, 'The following plugins were successfully uninstalled:')
+}
+
+function summarise (logger, list, iterator, header) {
+  if (!list || !iterator || list.length === 0) return
+  logger?.log(chalk.cyanBright(header))
+  list.forEach(item => iterator(item, logger))
+}

package/lib/integration/PluginManagement/unregister.js

@@ -0,0 +1,101 @@
+import getBowerRegistryConfig from '../getBowerRegistryConfig.js'
+import authenticate from './autenticate.js'
+import fs from 'fs-extra'
+import path from 'path'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { readValidateJSON } from '../../util/JSONReadValidate.js'
+import Plugin from '../Plugin.js'
+import request from 'request'
+
+export default async function unregister ({
+  logger,
+  cwd = process.cwd(),
+  pluginName
+} = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd })
+  logger?.warn('Using registry at', BOWER_REGISTRY_CONFIG.register)
+  try {
+    const bowerJSONPath = path.join(cwd, 'bower.json')
+    const hasBowerJSON = fs.existsSync(bowerJSONPath)
+    const bowerJSON = hasBowerJSON ? await readValidateJSON(bowerJSONPath) : {}
+    if (pluginName) bowerJSON.name = pluginName
+    const props = await confirm(bowerJSON)
+    pluginName = props.pluginName
+    const repository = props.repository
+    const { username, token, type } = await authenticate({ repository, pluginName })
+    logger?.log(`${username} authenticated as ${type}`)
+    await finalConfirm()
+    await unregisterInBowerRepo({ pluginName, username, token, BOWER_REGISTRY_CONFIG })
+    logger?.log(chalk.green('The plugin was successfully unregistered.'))
+  } catch (err) {
+    logger?.error(err)
+    logger?.log('The plugin was not unregistered.')
+  }
+}
+
+async function confirm (properties) {
+  const plugin = new Plugin({ name: properties.name })
+  const schema = [
+    {
+      name: 'pluginName',
+      message: chalk.cyan('name'),
+      validate: v => {
+        return /^adapt-[\w|-]+?$/.test(v) ||
+            'Name must prefixed with \'adapt\' and each word separated with a hyphen(-)'
+      },
+      type: 'input',
+      default: plugin.toString() || 'not specified'
+    },
+    {
+      name: 'repository',
+      message: chalk.cyan('repository URL'),
+      validate: v => {
+        return /https:\/\/([\w.@:/\-~]+)(\.git)(\/)?/.test(v) ||
+            'Please provide a repository URL of the form https://<domain><path>.git'
+      },
+      type: 'input',
+      default: properties.repository ? properties.repository.url : undefined
+    }
+  ]
+  return await inquirer.prompt(schema)
+}
+
+async function finalConfirm () {
+  const schema = [
+    {
+      name: 'ready',
+      message: chalk.cyan('Confirm Unregister now?'),
+      type: 'confirm',
+      default: true
+    }
+  ]
+  const confirmation = await inquirer.prompt(schema)
+  if (!confirmation.ready) throw new Error('Aborted. Nothing has been unregistered.')
+}
+
+async function unregisterInBowerRepo ({
+  pluginName,
+  username,
+  token,
+  BOWER_REGISTRY_CONFIG
+}) {
+  const uri = `${BOWER_REGISTRY_CONFIG.register}packages/${username}/${pluginName}?access_token=${token}`
+  return new Promise((resolve, reject) => {
+    request({
+      uri,
+      method: 'DELETE',
+      headers: { 'User-Agent': 'adapt-cli' },
+      followRedirect: false
+    }, (err, res, body) => {
+      if (err) return reject(err)
+      if (res.statusCode !== 204) reject(new Error(`The server responded with ${res.statusCode}`))
+      try {
+        resolve()
+      } catch (err) {
+        reject(err)
+      }
+    })
+  })
+}