netlify-cli 8.0.13 → 8.1.0-rc.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "8.0.13",
+  "version": "8.1.0-rc.2",
   "author": "Netlify Inc.",
   "contributors": [
     "Mathias Biilmann <matt@netlify.com> (https://twitter.com/biilmann)",
@@ -57,7 +57,6 @@
     "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
     "test:dev": "run-s test:init:* test:dev:*",
     "test:ci": "run-s test:init:* test:ci:*",
-    "test:init:build": "run-s build:*",
     "test:init:cli-version": "npm run start -- --version",
     "test:init:cli-help": "npm run start -- --help",
     "test:init:eleventy-deps": "npm ci --prefix tests/eleventy-site --no-audit",
@@ -66,9 +65,8 @@
     "test:ci:ava": "nyc -r json ava",
     "docs": "node ./site/scripts/docs.js",
     "watch": "nyc --reporter=lcov ava --watch",
-    "build:manifest": "oclif-dev manifest",
-    "prepack": "npm run build:manifest && npm prune --prod",
-    "postpack": "rm -f oclif.manifest.json && npm i",
+    "prepack": "npm prune --prod",
+    "postpack": "npm i",
     "site:build": "run-s site:build:*",
     "site:build:install": "cd site && npm ci --no-audit",
     "site:build:assets": "cd site && npm run build",
@@ -79,21 +77,14 @@
     "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,scripts,site,tests,.github}/**/*.{js,md,yml,json,html}\" \"*.{js,yml,json,html}\" \".*.{js,yml,json,html}\" \"!CHANGELOG.md\" \"!npm-shrinkwrap.json\" \"!.github/**/*.md\""
   },
   "dependencies": {
-    "@netlify/build": "^20.0.3",
+    "@netlify/build": "^20.0.2",
     "@netlify/config": "^16.0.5",
     "@netlify/framework-info": "^6.0.0",
     "@netlify/local-functions-proxy": "^1.1.1",
     "@netlify/plugin-edge-handlers": "^2.0.0",
-    "@netlify/plugins-list": "^6.0.1",
+    "@netlify/plugins-list": "^5.0.0",
     "@netlify/routing-local-proxy": "^0.34.1",
     "@netlify/zip-it-and-ship-it": "5.2.0",
-    "@oclif/command": "^1.6.1",
-    "@oclif/config": "^1.15.1",
-    "@oclif/errors": "^1.3.4",
-    "@oclif/parser": "^3.8.4",
-    "@oclif/plugin-help": "^3.0.0",
-    "@oclif/plugin-not-found": "^1.1.4",
-    "@oclif/plugin-plugins": "^1.9.3",
     "@octokit/rest": "^18.0.0",
     "@sindresorhus/slugify": "^1.1.0",
     "ansi-styles": "^5.0.0",
@@ -106,6 +97,7 @@
     "ci-info": "^3.0.0",
     "clean-deep": "^3.0.2",
     "cli-ux": "^5.5.1",
+    "commander": "^8.3.0",
     "concordance": "^5.0.0",
     "configstore": "^5.0.0",
     "content-type": "^1.0.4",
@@ -140,6 +132,7 @@
     "inquirer-autocomplete-prompt": "^1.0.1",
     "is-docker": "^2.0.0",
     "is-plain-obj": "^3.0.0",
+    "is-wsl": "^2.2.0",
     "isexe": "^2.0.0",
     "jwt-decode": "^3.0.0",
     "lambda-local": "^2.0.0",
@@ -154,11 +147,10 @@
     "multiparty": "^4.2.1",
     "netlify": "^10.0.0",
     "netlify-headers-parser": "^5.0.0",
-    "netlify-redirect-parser": "^13.0.0",
+    "netlify-redirect-parser": "^12.0.0",
     "netlify-redirector": "^0.2.1",
     "node-fetch": "^2.6.0",
     "node-version-alias": "^1.0.1",
-    "oclif-plugin-completion": "^0.6.0",
     "omit.js": "^2.0.2",
     "open": "^7.0.0",
     "ora": "^5.0.0",
@@ -177,9 +169,10 @@
     "raw-body": "^2.4.1",
     "read-pkg-up": "^7.0.1",
     "resolve": "^1.12.0",
-    "semver": "^7.3.4",
+    "semver": "^7.3.5",
     "source-map-support": "^0.5.19",
     "static-server": "^2.2.1",
+    "string-similarity": "^4.0.4",
     "strip-ansi-control-characters": "^2.0.0",
     "tempy": "^1.0.0",
     "through2-filter": "^3.0.0",
@@ -198,9 +191,8 @@
     "@commitlint/cli": "^15.0.0",
     "@commitlint/config-conventional": "^15.0.0",
     "@netlify/eslint-config-node": "^3.3.11",
-    "@oclif/dev-cli": "^1.23.1",
-    "@oclif/test": "^1.2.5",
     "ava": "^3.15.0",
+    "eslint-plugin-local-rules": "file:tools/eslint-rules",
     "eslint-plugin-sort-destructure-keys": "^1.3.5",
     "form-data": "^4.0.0",
     "from2-string": "^1.1.0",
@@ -223,7 +215,9 @@
   },
   "ava": {
     "files": [
+      "site/**/*.test.js",
       "src/**/*.test.js",
+      "tools/**/*.test.js",
       "tests/*.test.js"
     ],
     "cache": true,
@@ -233,22 +227,6 @@
     "tap": false,
     "timeout": "5m"
   },
-  "oclif": {
-    "bin": "netlify",
-    "commands": "./src/commands",
-    "helpClass": "./src/lib/help",
-    "plugins": [
-      "@oclif/plugin-not-found",
-      "@oclif/plugin-plugins",
-      "@oclif/plugin-help",
-      "oclif-plugin-completion"
-    ],
-    "hooks": {
-      "init": [
-        "./src/hooks/init"
-      ]
-    }
-  },
   "husky": {
     "hooks": {
       "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",

package/src/commands/addons/addons-auth.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+const { exit, log, openBrowser } = require('../../utils')
+const { ADDON_VALIDATION, prepareAddonCommand } = require('../../utils/addons/prepare')
+
+/**
+ * The addons:auth command
+ * @param {string} addonName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const addonsAuth = async (addonName, options, command) => {
+  const { addon } = await prepareAddonCommand({
+    command,
+    addonName,
+    // @ts-ignore when migrating to typescript this should be a const enum
+    validation: ADDON_VALIDATION.EXISTS,
+  })
+
+  if (!addon.auth_url) {
+    log(`No Admin URL found for the "${addonName} add-on"`)
+    return false
+  }
+
+  log()
+  log(`Opening ${addonName} add-on admin URL:`)
+  log()
+  log(addon.auth_url)
+  log()
+  await openBrowser({ url: addon.auth_url })
+  exit()
+}
+
+/**
+ * Creates the `netlify addons:auth` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsAuthCommand = (program) =>
+  program
+    .command('addons:auth')
+    .alias('addon:auth')
+    .argument('<name>', 'Add-on slug')
+    .description('Login to add-on provider')
+    .action(async (addonName, options, command) => {
+      await addonsAuth(addonName, options, command)
+    })
+
+module.exports = { createAddonsAuthCommand }

package/src/commands/addons/addons-config.js

@@ -0,0 +1,180 @@
+// @ts-check
+const inquirer = require('inquirer')
+const isEmpty = require('lodash/isEmpty')
+
+const { chalk, error, log, parseRawFlags } = require('../../utils')
+const compare = require('../../utils/addons/compare')
+const diffValues = require('../../utils/addons/diffs')
+const { ADDON_VALIDATION, prepareAddonCommand } = require('../../utils/addons/prepare')
+const generatePrompts = require('../../utils/addons/prompts')
+const render = require('../../utils/addons/render')
+const { missingConfigValues, requiredConfigValues, updateConfigValues } = require('../../utils/addons/validation')
+
+const update = async function ({ addonName, api, currentConfig, instanceId, newConfig, siteId }) {
+  const codeDiff = diffValues(currentConfig, newConfig)
+  if (!codeDiff) {
+    log('No changes, exiting early')
+    return false
+  }
+  log()
+  const msg = `Updating ${addonName} add-on config values...`
+  log(`${chalk.white.bold(msg)}`)
+  log()
+  log(`${codeDiff}\n`)
+  log()
+
+  try {
+    await api.updateServiceInstance({
+      siteId,
+      addon: addonName,
+      instanceId,
+      body: { config: newConfig },
+    })
+    log(`Add-on "${addonName}" successfully updated`)
+  } catch (error_) {
+    error(error_.message)
+  }
+}
+
+/**
+ * The addons:config command
+ * @param {string} addonName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const addonsConfig = async (addonName, options, command) => {
+  const { addon, manifest, siteData } = await prepareAddonCommand({
+    command,
+    addonName,
+    // @ts-ignore
+    validation: ADDON_VALIDATION.EXISTS,
+  })
+
+  const { api, site } = command.netlify
+  const siteId = site.id
+
+  const hasConfig = !isEmpty(manifest.config)
+  // Parse flags
+  const rawFlags = parseRawFlags(command.args)
+  // Get Existing Config
+  const currentConfig = addon.config || {}
+
+  const words = `Current "${addonName} add-on" Settings:`
+  log(` ${chalk.yellowBright.bold(words)}`)
+  if (hasConfig) {
+    if (!rawFlags.silent) {
+      render.configValues(addonName, manifest.config, currentConfig)
+    }
+  } else {
+    // For addons without manifest. TODO remove once we enforce manifests
+    Object.keys(currentConfig).forEach((key) => {
+      log(`${key} - ${currentConfig[key]}`)
+    })
+  }
+
+  if (hasConfig) {
+    const required = requiredConfigValues(manifest.config)
+    const missingValues = missingConfigValues(required, rawFlags)
+
+    /* Config set by command line flags */
+    if (rawFlags && missingValues.length === 0) {
+      const newConfig = updateConfigValues(manifest.config, currentConfig, rawFlags)
+
+      await update({
+        addonName,
+        currentConfig,
+        newConfig,
+        siteId,
+        instanceId: addon.id,
+        api,
+      })
+      return false
+    }
+
+    const updatePrompt = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'updateNow',
+        message: `Do you want to update config values?`,
+        default: false,
+      },
+    ])
+    if (!updatePrompt.updateNow) {
+      log('Sounds good! Exiting configuration...')
+      return false
+    }
+    log()
+    log(` - Hit ${chalk.white.bold('enter')} to keep the existing value in (parentheses)`)
+    log(` - Hit ${chalk.white.bold('down arrow')} to remove the value`)
+    log(` - Hit ${chalk.white.bold('ctrl + C')} to cancel & exit configuration`)
+    log()
+    log(` You will need to verify the changed before we push them to your live site!`)
+    log()
+    const prompts = generatePrompts({
+      config: manifest.config,
+      configValues: currentConfig,
+    })
+    const userInput = await inquirer.prompt(prompts)
+    // Merge user input with the flags specified
+    const newConfig = updateConfigValues(manifest.config, currentConfig, userInput)
+
+    const diffs = compare(currentConfig, newConfig)
+    // log('compare', diffs)
+    if (diffs.isEqual) {
+      log(`No changes. exiting early`)
+      return false
+    }
+    log()
+    log(`${chalk.yellowBright.bold.underline('Confirm your updates:')}`)
+    log()
+    diffs.keys.forEach((key) => {
+      const { newValue, oldValue } = diffs.diffs[key]
+      const oldVal = oldValue || 'NO VALUE'
+      log(`${chalk.cyan(key)} changed from ${chalk.whiteBright(oldVal)} to ${chalk.green(newValue)}`)
+    })
+    log()
+
+    const confirmPrompt = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmChange',
+        message: `Do you want to publish the updated "${addonName} add-on" settings for ${chalk.cyan(siteData.name)}?`,
+        default: false,
+      },
+    ])
+
+    if (!confirmPrompt.confirmChange) {
+      log('Canceling changes... You are good to go!')
+      return false
+    }
+
+    await update({
+      addonName,
+      currentConfig,
+      newConfig,
+      siteId,
+      instanceId: addon.id,
+      api,
+    })
+  }
+}
+
+/**
+ * Creates the `netlify addons:config` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsConfigCommand = (program) =>
+  program
+    .command('addons:config')
+    .alias('addon:config')
+    .argument('<name>', 'Add-on namespace')
+    .description('Configure add-on settings')
+    // allow for any flags. Handy for variadic configuration options
+    .allowUnknownOption(true)
+    .action(async (addonName, options, command) => {
+      await addonsConfig(addonName, options, command)
+    })
+
+module.exports = { createAddonsConfigCommand }

package/src/commands/addons/addons-create.js

@@ -0,0 +1,131 @@
+// @ts-check
+const inquirer = require('inquirer')
+const isEmpty = require('lodash/isEmpty')
+
+const { chalk, error, log, parseRawFlags } = require('../../utils')
+const { ADDON_VALIDATION, prepareAddonCommand } = require('../../utils/addons/prepare')
+const generatePrompts = require('../../utils/addons/prompts')
+const render = require('../../utils/addons/render')
+const { missingConfigValues, requiredConfigValues, updateConfigValues } = require('../../utils/addons/validation')
+
+const createAddon = async ({ addonName, api, config, siteData, siteId }) => {
+  try {
+    const response = await api.createServiceInstance({
+      siteId,
+      addon: addonName,
+      body: { config },
+    })
+    log(`Add-on "${addonName}" created for ${siteData.name}`)
+    if (response.config && response.config.message) {
+      log()
+      log(`${response.config.message}`)
+    }
+  } catch (error_) {
+    error(error_.message)
+  }
+}
+
+/**
+ * The addons:create command
+ * @param {string} addonName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const addonsCreate = async (addonName, options, command) => {
+  const { manifest, siteData } = await prepareAddonCommand({
+    command,
+    addonName,
+    // @ts-ignore
+    validation: ADDON_VALIDATION.NOT_EXISTS,
+  })
+
+  const { api, site } = command.netlify
+  const siteId = site.id
+
+  // GET flags from `raw` data
+  const rawFlags = parseRawFlags(command.args)
+  const hasConfig = !isEmpty(manifest.config)
+
+  let configValues = rawFlags
+
+  if (hasConfig) {
+    const required = requiredConfigValues(manifest.config)
+    const missingValues = missingConfigValues(required, rawFlags)
+    log(`Starting the setup for "${addonName} add-on"`)
+    log()
+
+    if (Object.keys(rawFlags).length !== 0) {
+      const newConfig = updateConfigValues(manifest.config, {}, rawFlags)
+
+      if (missingValues.length !== 0) {
+        /* Warn user of missing required values */
+        log(`${chalk.redBright.underline.bold(`Error: Missing required configuration for "${addonName} add-on"`)}`)
+        log()
+        render.missingValues(missingValues, manifest)
+        log()
+        const msg = `netlify addons:create ${addonName}`
+        log(`Please supply the configuration values as CLI flags`)
+        log()
+        log(`Alternatively, you can run ${chalk.cyan(msg)} with no flags to walk through the setup steps`)
+        log()
+        return false
+      }
+
+      await createAddon({ api, siteId, addonName, config: newConfig, siteData })
+
+      return false
+    }
+
+    const words = `The ${addonName} add-on has the following configurable options:`
+    log(` ${chalk.yellowBright.bold(words)}`)
+    render.configValues(addonName, manifest.config)
+    log()
+    log(` ${chalk.greenBright.bold('Lets configure those!')}`)
+
+    log()
+    log(` - Hit ${chalk.white.bold('enter')} to confirm value or set empty value`)
+    log(` - Hit ${chalk.white.bold('ctrl + C')} to cancel & exit configuration`)
+    log()
+
+    const prompts = generatePrompts({
+      config: manifest.config,
+      configValues: rawFlags,
+    })
+
+    const userInput = await inquirer.prompt(prompts)
+    // Merge user input with the flags specified
+    configValues = updateConfigValues(manifest.config, rawFlags, userInput)
+    const missingRequiredValues = missingConfigValues(required, configValues)
+    if (missingRequiredValues && missingRequiredValues.length !== 0) {
+      missingRequiredValues.forEach((val) => {
+        log(`Missing required value "${val}". Please run the command again`)
+      })
+      return false
+    }
+  }
+
+  await createAddon({ api, siteId, addonName, config: configValues, siteData })
+}
+
+/**
+ * Creates the `netlify addons:create` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsCreateCommand = (program) =>
+  program
+    .command('addons:create')
+    .alias('addon:create')
+    .argument('<name>', 'Add-on namespace')
+    .description(
+      `Add an add-on extension to your site
+Add-ons are a way to extend the functionality of your Netlify site`,
+    )
+    // allow for any flags. Handy for variadic configuration options
+    .allowUnknownOption(true)
+    .action(async (addonName, options, command) => {
+      await addonsCreate(addonName, options, command)
+    })
+
+module.exports = { createAddonsCreateCommand }

package/src/commands/addons/addons-delete.js

@@ -0,0 +1,60 @@
+// @ts-check
+const inquirer = require('inquirer')
+
+const { error, exit, log } = require('../../utils')
+const { ADDON_VALIDATION, prepareAddonCommand } = require('../../utils/addons/prepare')
+
+/**
+ * The addons:delete command
+ * @param {string} addonName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const addonsDelete = async (addonName, options, command) => {
+  const { addon } = await prepareAddonCommand({
+    command,
+    addonName,
+    // @ts-ignore.
+    validation: ADDON_VALIDATION.EXISTS,
+  })
+  if (!options.force && !options.f) {
+    const { wantsToDelete } = await inquirer.prompt({
+      type: 'confirm',
+      name: 'wantsToDelete',
+      message: `Are you sure you want to delete the ${addonName} add-on? (to skip this prompt, pass a --force flag)`,
+      default: false,
+    })
+    if (!wantsToDelete) {
+      exit()
+    }
+  }
+
+  try {
+    await command.netlify.api.deleteServiceInstance({
+      siteId: command.netlify.site.id,
+      addon: addonName,
+      instanceId: addon.id,
+    })
+    log(`Addon "${addonName}" deleted`)
+  } catch (error_) {
+    error(error_.message)
+  }
+}
+
+/**
+ * Creates the `netlify addons:delete` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsDeleteCommand = (program) =>
+  program
+    .command('addons:delete')
+    .alias('addon:delete')
+    .argument('<name>', 'Add-on namespace')
+    .description(
+      `Remove an add-on extension to your site\nAdd-ons are a way to extend the functionality of your Netlify site`,
+    )
+    .option('-f, --force', 'delete without prompting (useful for CI)')
+    .action(addonsDelete)
+
+module.exports = { createAddonsDeleteCommand }

package/src/commands/addons/addons-list.js

@@ -0,0 +1,62 @@
+// @ts-check
+
+const AsciiTable = require('ascii-table')
+
+const { log, logJson } = require('../../utils')
+const { prepareAddonCommand } = require('../../utils/addons/prepare')
+
+/**
+ * The addons:list command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const addonsList = async (options, command) => {
+  const { addons, siteData } = await prepareAddonCommand({ command })
+  // Return json response for piping commands
+  if (options.json) {
+    logJson(addons)
+    return false
+  }
+
+  if (!addons || addons.length === 0) {
+    log(`No addons currently installed for ${siteData.name}`)
+    log(`> Run \`netlify addons:create addon-namespace\` to install an addon`)
+    return false
+  }
+
+  const addonData = addons.map((addon) => ({
+    namespace: addon.service_path.replace('/.netlify/', ''),
+    name: addon.service_name,
+    id: addon.id,
+  }))
+
+  // Build a table out of addons
+  log(`site: ${siteData.name}`)
+  const table = new AsciiTable(`Currently Installed addons`)
+
+  table.setHeading('NameSpace', 'Name', 'Instance Id')
+
+  addonData.forEach(({ id, name, namespace }) => {
+    table.addRow(namespace, name, id)
+  })
+  // Log da addons
+  log(table.toString())
+}
+
+/**
+ * Creates the `netlify addons:list` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsListCommand = (program) =>
+  program
+    .command('addons:list')
+    .alias('addon:list')
+    .description(`List currently installed add-ons for site`)
+    .option('--json', 'Output add-on data as JSON')
+    .action(async (options, command) => {
+      await addonsList(options, command)
+    })
+
+module.exports = { createAddonsListCommand }

package/src/commands/addons/addons.js

@@ -0,0 +1,44 @@
+// @ts-check
+
+const { createAddonsAuthCommand } = require('./addons-auth')
+const { createAddonsConfigCommand } = require('./addons-config')
+const { createAddonsCreateCommand } = require('./addons-create')
+const { createAddonsDeleteCommand } = require('./addons-delete')
+const { createAddonsListCommand } = require('./addons-list')
+
+/**
+ * The addons command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const addons = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify addons` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createAddonsCommand = (program) => {
+  createAddonsAuthCommand(program)
+  createAddonsConfigCommand(program)
+  createAddonsCreateCommand(program)
+  createAddonsDeleteCommand(program)
+  createAddonsListCommand(program)
+
+  return program
+    .command('addons')
+    .alias('addon')
+    .description('(Beta) Manage Netlify Add-ons')
+    .noHelpOptions()
+    .addExamples([
+      'netlify addons:create addon-xyz',
+      'netlify addons:list',
+      'netlify addons:config addon-xyz',
+      'netlify addons:delete addon-xyz',
+      'netlify addons:auth addon-xyz',
+    ])
+    .action(addons)
+}
+module.exports = { createAddonsCommand }

package/src/commands/addons/index.js

@@ -1,26 +1,5 @@
-const { isEmptyCommand } = require('../../utils/check-command-inputs')
-const showHelp = require('../../utils/show-help')
-const { TrackedCommand } = require('../../utils/telemetry/tracked-command')
+const { createAddonsCommand } = require('./addons')
 
-class AddonsCommand extends TrackedCommand {
-  run() {
-    const { args, flags } = this.parse(AddonsCommand)
-
-    // Show help on empty sub command
-    if (isEmptyCommand(flags, args)) {
-      showHelp(this.id)
-    }
-  }
+module.exports = {
+  createAddonsCommand,
 }
-
-AddonsCommand.description = `(Beta) Manage Netlify Add-ons`
-AddonsCommand.aliases = ['addon']
-AddonsCommand.examples = [
-  'netlify addons:create addon-xyz',
-  'netlify addons:list',
-  'netlify addons:config addon-xyz',
-  'netlify addons:delete addon-xyz',
-  'netlify addons:auth addon-xyz',
-]
-
-module.exports = AddonsCommand