netlify-cli 8.1.0 → 8.1.5

package/src/commands/addons/create.js

@@ -1,127 +0,0 @@
-const chalk = require('chalk')
-const inquirer = require('inquirer')
-const isEmpty = require('lodash/isEmpty')
-
-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 Command = require('../../utils/command')
-const { error, log } = require('../../utils/command-helpers')
-const { parseRawFlags } = require('../../utils/parse-raw-flags')
-
-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)
-  }
-}
-
-class AddonsCreateCommand extends Command {
-  async run() {
-    const { args, raw } = this.parse(AddonsCreateCommand)
-
-    const addonName = args.name
-    const { manifest, siteData } = await prepareAddonCommand({
-      context: this,
-      addonName,
-      validation: ADDON_VALIDATION.NOT_EXISTS,
-    })
-
-    const { netlify } = this
-    const { api, site } = netlify
-    const siteId = site.id
-
-    // GET flags from `raw` data
-    const rawFlags = parseRawFlags(raw)
-    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 })
-  }
-}
-
-AddonsCreateCommand.description = `Add an add-on extension to your site
-...
-Add-ons are a way to extend the functionality of your Netlify site
-`
-AddonsCreateCommand.aliases = ['addon:create']
-AddonsCreateCommand.args = [
-  {
-    name: 'name',
-    required: true,
-    description: 'Add-on namespace',
-  },
-]
-
-// allow for any flags. Handy for variadic configuration options
-AddonsCreateCommand.strict = false
-
-module.exports = AddonsCreateCommand

package/src/commands/addons/delete.js

@@ -1,69 +0,0 @@
-const { flags: flagsLib } = require('@oclif/command')
-const inquirer = require('inquirer')
-
-const { ADDON_VALIDATION, prepareAddonCommand } = require('../../utils/addons/prepare')
-const Command = require('../../utils/command')
-const { error, exit, log } = require('../../utils/command-helpers')
-const { parseRawFlags } = require('../../utils/parse-raw-flags')
-
-class AddonsDeleteCommand extends Command {
-  async run() {
-    const { args, raw } = this.parse(AddonsDeleteCommand)
-
-    const addonName = args.name
-    const { addon } = await prepareAddonCommand({
-      context: this,
-      addonName,
-      validation: ADDON_VALIDATION.EXISTS,
-    })
-
-    const rawFlags = parseRawFlags(raw)
-    if (!rawFlags.force && !rawFlags.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 this.netlify.api.deleteServiceInstance({
-        siteId: this.netlify.site.id,
-        addon: addonName,
-        instanceId: addon.id,
-      })
-      log(`Addon "${addonName}" deleted`)
-    } catch (error_) {
-      error(error_.message)
-    }
-  }
-}
-
-AddonsDeleteCommand.description = `Remove 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
-AddonsDeleteCommand.strict = false
-AddonsDeleteCommand.aliases = ['addon:delete']
-AddonsDeleteCommand.flags = {
-  force: flagsLib.boolean({
-    char: 'f',
-    description: 'delete without prompting (useful for CI)',
-  }),
-  ...AddonsDeleteCommand.flags,
-}
-AddonsDeleteCommand.args = [
-  {
-    name: 'name',
-    required: true,
-    description: 'Add-on namespace',
-  },
-]
-
-module.exports = AddonsDeleteCommand

package/src/commands/addons/list.js

@@ -1,54 +0,0 @@
-const { flags: flagsLib } = require('@oclif/command')
-const AsciiTable = require('ascii-table')
-
-const { prepareAddonCommand } = require('../../utils/addons/prepare')
-const Command = require('../../utils/command')
-const { log, logJson } = require('../../utils/command-helpers')
-
-class AddonsListCommand extends Command {
-  async run() {
-    const { flags } = this.parse(AddonsListCommand)
-
-    const { addons, siteData } = await prepareAddonCommand({ context: this })
-    // Return json response for piping commands
-    if (flags.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())
-  }
-}
-
-AddonsListCommand.description = `List currently installed add-ons for site`
-AddonsListCommand.aliases = ['addon:list']
-AddonsListCommand.flags = {
-  json: flagsLib.boolean({
-    description: 'Output add-on data as JSON',
-  }),
-  ...AddonsListCommand.flags,
-}
-
-module.exports = AddonsListCommand

package/src/commands/api.js

@@ -1,84 +0,0 @@
-const oclif = require('@oclif/command')
-const AsciiTable = require('ascii-table')
-const chalk = require('chalk')
-
-// TODO: use static `import` after migrating this repository to pure ES modules
-const jsClient = import('netlify')
-
-const { isEmptyCommand } = require('../utils/check-command-inputs')
-const Command = require('../utils/command')
-const { error, exit, log, logJson } = require('../utils/command-helpers')
-
-class APICommand extends Command {
-  async run() {
-    const { api } = this.netlify
-    const { args, flags } = this.parse(APICommand)
-
-    const { apiMethod } = args
-
-    if (isEmptyCommand(flags, args) || flags.list) {
-      const table = new AsciiTable(`Netlify API Methods`)
-      table.setHeading('API Method', 'Docs Link')
-      const { methods } = await jsClient
-      methods.forEach((method) => {
-        const { operationId } = method
-        table.addRow(operationId, `https://open-api.netlify.com/#operation/${operationId}`)
-      })
-      log(table.toString())
-      log()
-      log('Above is a list of available API methods')
-      log(`To run a method use "${chalk.cyanBright('netlify api methodName')}"`)
-      exit()
-    }
-
-    if (!apiMethod) {
-      error(`You must provide an API method. Run "netlify api --list" to see available methods`)
-    }
-
-    if (!api[apiMethod] || typeof api[apiMethod] !== 'function') {
-      error(`"${apiMethod}"" is not a valid api method. Run "netlify api --list" to see available methods`)
-    }
-
-    let payload
-    if (flags.data) {
-      payload = typeof flags.data === 'string' ? JSON.parse(flags.data) : flags.data
-    } else {
-      payload = {}
-    }
-    try {
-      const apiResponse = await api[apiMethod](payload)
-      logJson(apiResponse)
-    } catch (error_) {
-      error(error_)
-    }
-  }
-}
-
-APICommand.description = `Run any Netlify API method
-
-For more information on available methods checkout https://open-api.netlify.com/ or run "netlify api --list"
-`
-
-APICommand.args = [
-  {
-    name: 'apiMethod',
-    description: 'Open API method to run',
-  },
-]
-
-APICommand.examples = ['netlify api --list', 'netlify api getSite --data \'{ "site_id": "123456"}\'']
-
-APICommand.flags = {
-  data: oclif.flags.string({
-    char: 'd',
-    description: 'Data to use',
-  }),
-  list: oclif.flags.boolean({
-    description: 'List out available API methods',
-  }),
-  ...APICommand.flags,
-}
-
-APICommand.strict = false
-
-module.exports = APICommand

package/src/commands/dev/exec.js

@@ -1,32 +0,0 @@
-const execa = require('execa')
-
-const Command = require('../../utils/command')
-const { injectEnvVariables } = require('../../utils/dev')
-
-class ExecCommand extends Command {
-  async init() {
-    this.commandContext = 'dev'
-    await super.init()
-  }
-
-  async run() {
-    const { netlify } = this
-    const { cachedConfig, site } = netlify
-    await injectEnvVariables({ env: cachedConfig.env, site })
-
-    execa(this.argv[0], this.argv.slice(1), {
-      stdio: 'inherit',
-    })
-  }
-}
-
-ExecCommand.description = `Exec command
-Runs a command within the netlify dev environment, e.g. with env variables from any installed addons
-`
-
-ExecCommand.examples = ['$ netlify dev:exec npm run bootstrap']
-
-ExecCommand.strict = false
-ExecCommand.parse = false
-
-module.exports = ExecCommand

package/src/commands/dev/trace.js

@@ -1,61 +0,0 @@
-const { flags } = require('@oclif/command')
-
-const Command = require('../../utils/command')
-const { runProcess } = require('../../utils/traffic-mesh')
-
-class TraceCommand extends Command {
-  async init() {
-    this.commandContext = 'dev'
-    await super.init()
-  }
-
-  async run() {
-    this.parse(TraceCommand)
-
-    const args = ['trace', ...this.argv]
-    const { subprocess } = runProcess({ args })
-    await subprocess
-  }
-}
-
-TraceCommand.description = `Trace command
-Simulates Netlify's Edge routing logic to match specific requests.
-This command is designed to mimic cURL's command line, so the flags are more familiar.
-`
-
-TraceCommand.examples = [
-  '$ netlify dev:trace http://localhost/routing-path',
-  '$ netlify dev:trace -w dist-directory http://localhost/routing-path',
-  '$ netlify dev:trace -X POST http://localhost/routing-path',
-  '$ netlify dev:trace -H "Accept-Language es" http://localhost/routing-path',
-  '$ netlify dev:trace --cookie nf_jwt=token http://localhost/routing-path',
-]
-TraceCommand.strict = false
-TraceCommand.args = [
-  {
-    name: 'url',
-    required: true,
-    description: 'Sets the request URL',
-  },
-]
-TraceCommand.flags = {
-  request: flags.string({
-    char: 'X',
-    description: 'Specifies a custom request method [default: GET]',
-  }),
-  cookie: flags.string({
-    char: 'b',
-    description: 'Request cookie, this flag can be used multiple times. Example: "nf_jwt=token"',
-  }),
-  header: flags.string({
-    char: 'H',
-    description: 'Request header, this flag can be used multiple times. Example: "Host: netlify.test"',
-  }),
-  watch: flags.string({
-    char: 'w',
-    description: 'Path to the publish directory',
-  }),
-  debug: TraceCommand.flags.debug,
-}
-
-module.exports = TraceCommand

package/src/commands/env/get.js

@@ -1,44 +0,0 @@
-const Command = require('../../utils/command')
-const { log, logJson } = require('../../utils/command-helpers')
-
-class EnvGetCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(EnvGetCommand)
-    const { api, cachedConfig, site } = this.netlify
-    const siteId = site.id
-
-    if (!siteId) {
-      log('No site id found, please run inside a site folder or `netlify link`')
-      return false
-    }
-
-    const siteData = await api.getSite({ siteId })
-
-    const { name } = args
-    const { value } = cachedConfig.env[name] || {}
-
-    // Return json response for piping commands
-    if (flags.json) {
-      logJson(value ? { [name]: value } : {})
-      return false
-    }
-
-    if (!value) {
-      log(`Environment variable ${name} not set for site ${siteData.name}`)
-      return false
-    }
-
-    log(value)
-  }
-}
-
-EnvGetCommand.description = `Get resolved value of specified environment variable (includes netlify.toml)`
-EnvGetCommand.args = [
-  {
-    name: 'name',
-    required: true,
-    description: 'Environment variable name',
-  },
-]
-
-module.exports = EnvGetCommand

package/src/commands/env/import.js

@@ -1,90 +0,0 @@
-const fs = require('fs')
-
-const { flags: flagsLib } = require('@oclif/command')
-const AsciiTable = require('ascii-table')
-const dotenv = require('dotenv')
-const isEmpty = require('lodash/isEmpty')
-
-const Command = require('../../utils/command')
-const { exit, log, logJson } = require('../../utils/command-helpers')
-
-class EnvImportCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(EnvImportCommand)
-    const { api, site } = this.netlify
-    const siteId = site.id
-
-    if (!siteId) {
-      log('No site id found, please run inside a site folder or `netlify link`')
-      return false
-    }
-
-    const siteData = await api.getSite({ siteId })
-
-    // Get current environment variables set in the UI
-    const {
-      build_settings: { env = {} },
-    } = siteData
-
-    // Import environment variables from specified .env file
-    const { fileName } = args
-    let importedEnv = {}
-    try {
-      const envFileContents = fs.readFileSync(fileName)
-      importedEnv = dotenv.parse(envFileContents)
-    } catch (error) {
-      log(error.message)
-      exit(1)
-    }
-
-    if (isEmpty(importedEnv)) {
-      log(`No environment variables found in file ${fileName} to import`)
-      return false
-    }
-
-    // Apply environment variable updates
-    const siteResult = await api.updateSite({
-      siteId,
-      body: {
-        build_settings: {
-          // Only set imported variables if --replaceExisting or otherwise merge
-          // imported ones with the current environment variables.
-          env: flags.replaceExisting ? importedEnv : { ...env, ...importedEnv },
-        },
-      },
-    })
-
-    // Return new environment variables of site if using json flag
-    if (flags.json) {
-      logJson(siteResult.build_settings.env)
-      return false
-    }
-
-    // List newly imported environment variables in a table
-    log(`site: ${siteData.name}`)
-    const table = new AsciiTable(`Imported environment variables`)
-
-    table.setHeading('Key', 'Value')
-    table.addRowMatrix(Object.entries(importedEnv))
-    log(table.toString())
-  }
-}
-
-EnvImportCommand.description = `Import and set environment variables from .env file`
-EnvImportCommand.flags = {
-  replaceExisting: flagsLib.boolean({
-    char: 'r',
-    description: 'Replace all existing variables instead of merging them with the current ones',
-    default: false,
-  }),
-  ...EnvImportCommand.flags,
-}
-EnvImportCommand.args = [
-  {
-    name: 'fileName',
-    required: true,
-    description: '.env file to import',
-  },
-]
-
-module.exports = EnvImportCommand

package/src/commands/env/list.js

@@ -1,49 +0,0 @@
-const AsciiTable = require('ascii-table')
-const isEmpty = require('lodash/isEmpty')
-
-const Command = require('../../utils/command')
-const { log, logJson } = require('../../utils/command-helpers')
-
-class EnvListCommand extends Command {
-  async run() {
-    const { flags } = this.parse(EnvListCommand)
-    const { api, cachedConfig, site } = this.netlify
-    const siteId = site.id
-
-    if (!siteId) {
-      log('No site id found, please run inside a site folder or `netlify link`')
-      return false
-    }
-
-    const siteData = await api.getSite({ siteId })
-    const environment = Object.fromEntries(
-      Object.entries(cachedConfig.env)
-        // Omitting general variables to reduce noise.
-        .filter(([, variable]) => variable.sources[0] !== 'general')
-        .map(([key, variable]) => [key, variable.value]),
-    )
-
-    // Return json response for piping commands
-    if (flags.json) {
-      logJson(environment)
-      return false
-    }
-
-    if (isEmpty(environment)) {
-      log(`No environment variables set for site ${siteData.name}`)
-      return false
-    }
-
-    // List environment variables using a table
-    log(`site: ${siteData.name}`)
-    const table = new AsciiTable(`Environment variables`)
-
-    table.setHeading('Key', 'Value')
-    table.addRowMatrix(Object.entries(environment))
-    log(table.toString())
-  }
-}
-
-EnvListCommand.description = `Lists resolved environment variables for site (includes netlify.toml)`
-
-module.exports = EnvListCommand

package/src/commands/env/set.js

@@ -1,64 +0,0 @@
-const Command = require('../../utils/command')
-const { log, logJson } = require('../../utils/command-helpers')
-
-class EnvSetCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(EnvSetCommand)
-    const { api, site } = this.netlify
-    const siteId = site.id
-
-    if (!siteId) {
-      log('No site id found, please run inside a site folder or `netlify link`')
-      return false
-    }
-
-    const siteData = await api.getSite({ siteId })
-
-    // Get current environment variables set in the UI
-    const {
-      build_settings: { env = {} },
-    } = siteData
-
-    // Merge new enviroment variable with currently set variables
-    const { name, value } = args
-    const newEnv = {
-      ...env,
-      [name]: value,
-    }
-
-    // Apply environment variable updates
-    const siteResult = await api.updateSite({
-      siteId,
-      body: {
-        build_settings: {
-          env: newEnv,
-        },
-      },
-    })
-
-    // Return new environment variables of site if using json flag
-    if (flags.json) {
-      logJson(siteResult.build_settings.env)
-      return false
-    }
-
-    log(`Set environment variable ${name}=${value} for site ${siteData.name}`)
-  }
-}
-
-EnvSetCommand.description = `Set value of environment variable`
-EnvSetCommand.args = [
-  {
-    name: 'name',
-    required: true,
-    description: 'Environment variable name',
-  },
-  {
-    name: 'value',
-    required: false,
-    default: '',
-    description: 'Value to set to',
-  },
-]
-
-module.exports = EnvSetCommand