netlify-cli 8.1.0 → 8.1.5

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

@@ -0,0 +1,187 @@
+// @ts-check
+
+const slugify = require('@sindresorhus/slugify')
+const inquirer = require('inquirer')
+const pick = require('lodash/pick')
+const sample = require('lodash/sample')
+const prettyjson = require('prettyjson')
+const { v4: uuidv4 } = require('uuid')
+
+const { chalk, error, getRepoData, log, logJson, track, warn } = require('../../utils')
+const { configureRepo } = require('../../utils/init/config')
+
+const SITE_NAME_SUGGESTION_SUFFIX_LENGTH = 5
+
+/**
+ * The sites:create command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const sitesCreate = async (options, command) => {
+  const { api } = command.netlify
+
+  await command.authenticate()
+
+  const accounts = await api.listAccountsForUser()
+
+  let { accountSlug } = options
+  if (!accountSlug) {
+    const { accountSlug: accountSlugInput } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'accountSlug',
+        message: 'Team:',
+        choices: accounts.map((account) => ({
+          value: account.slug,
+          name: account.name,
+        })),
+      },
+    ])
+    accountSlug = accountSlugInput
+  }
+
+  const { name: nameFlag } = options
+  let user
+  let site
+
+  // Allow the user to reenter site name if selected one isn't available
+  const inputSiteName = async (name) => {
+    if (!user) user = await api.getCurrentUser()
+
+    if (!name) {
+      let { slug } = user
+      let suffix = ''
+
+      // If the user doesn't have a slug, we'll compute one. Because `full_name` is not guaranteed to be unique, we
+      // append a short randomly-generated ID to reduce the likelihood of a conflict.
+      if (!slug) {
+        slug = slugify(user.full_name || user.email)
+        suffix = `-${uuidv4().slice(0, SITE_NAME_SUGGESTION_SUFFIX_LENGTH)}`
+      }
+
+      const suggestions = [
+        `super-cool-site-by-${slug}${suffix}`,
+        `the-awesome-${slug}-site${suffix}`,
+        `${slug}-makes-great-sites${suffix}`,
+        `netlify-thinks-${slug}-is-great${suffix}`,
+        `the-great-${slug}-site${suffix}`,
+        `isnt-${slug}-awesome${suffix}`,
+      ]
+      const siteSuggestion = sample(suggestions)
+
+      console.log(
+        `Choose a unique site name (e.g. ${siteSuggestion}.netlify.app) or leave it blank for a random name. You can update the site name later.`,
+      )
+      const { name: nameInput } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Site name (optional):',
+          filter: (val) => (val === '' ? undefined : val),
+          validate: (input) => /^[a-zA-Z\d-]+$/.test(input) || 'Only alphanumeric characters and hyphens are allowed',
+        },
+      ])
+      name = nameInput
+    }
+
+    const body = {}
+    if (typeof name === 'string') {
+      body.name = name.trim()
+    }
+    try {
+      site = await api.createSiteInTeam({
+        accountSlug,
+        body,
+      })
+    } catch (error_) {
+      if (error_.status === 422) {
+        warn(`${name}.netlify.app already exists. Please try a different slug.`)
+        await inputSiteName()
+      } else {
+        error(`createSiteInTeam error: ${error_.status}: ${error_.message}`)
+      }
+    }
+  }
+  await inputSiteName(nameFlag)
+
+  log()
+  log(chalk.greenBright.bold.underline(`Site Created`))
+  log()
+
+  const siteUrl = site.ssl_url || site.url
+  log(
+    prettyjson.render({
+      'Admin URL': site.admin_url,
+      URL: siteUrl,
+      'Site ID': site.id,
+    }),
+  )
+
+  track('sites_created', {
+    siteId: site.id,
+    adminUrl: site.admin_url,
+    siteUrl,
+  })
+
+  if (options.withCi) {
+    log('Configuring CI')
+    const repoData = await getRepoData()
+    await configureRepo({ command, siteId: site.id, repoData, manual: options.manual })
+  }
+
+  if (options.json) {
+    logJson(
+      pick(site, [
+        'id',
+        'state',
+        'plan',
+        'name',
+        'custom_domain',
+        'domain_aliases',
+        'url',
+        'ssl_url',
+        'admin_url',
+        'screenshot_url',
+        'created_at',
+        'updated_at',
+        'user_id',
+        'ssl',
+        'force_ssl',
+        'managed_dns',
+        'deploy_url',
+        'account_name',
+        'account_slug',
+        'git_provider',
+        'deploy_hook',
+        'capabilities',
+        'id_domain',
+      ]),
+    )
+  }
+
+  return site
+}
+
+/**
+ * Creates the `netlify sites:create` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createSitesCreateCommand = (program) =>
+  program
+    .command('sites:create')
+    .description(
+      `Create an empty site (advanced)
+Create a blank site that isn't associated with any git remote. Does not link to the current working directory.`,
+    )
+    .option('-n, --name [name]', 'name of site')
+    .option('-a, --account-slug [slug]', 'account slug to create the site under')
+    .option('-c, --with-ci', 'initialize CI hooks during site creation')
+    .option('-m, --manual', 'force manual CI setup.  Used --with-ci flag')
+    .addHelpText(
+      'after',
+      `Create a blank site that isn't associated with any git remote. Does not link to the current working directory.`,
+    )
+    .action(sitesCreate)
+
+module.exports = { createSitesCreateCommand, sitesCreate }

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

@@ -0,0 +1,104 @@
+// @ts-check
+const inquirer = require('inquirer')
+
+const { chalk, error, exit, log } = require('../../utils')
+
+/**
+ * The sites:delete command
+ * @param {string} siteId
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const sitesDelete = async (siteId, options, command) => {
+  command.setAnalyticsPayload({ force: options.force })
+
+  const { api, site } = command.netlify
+  const cwdSiteId = site.id
+
+  // 1. Prompt user for verification
+  await command.authenticate(options.auth)
+
+  let siteData
+  try {
+    siteData = await api.getSite({ siteId })
+  } catch (error_) {
+    if (error_.status === 404) {
+      error(`No site with id ${siteId} found. Please verify the siteId & try again.`)
+    }
+  }
+
+  if (!siteData) {
+    error(`Unable to process site`)
+  }
+
+  const noForce = options.force !== true
+
+  /* Verify the user wants to delete the site */
+  if (noForce) {
+    log(`${chalk.redBright('Warning')}: You are about to permanently delete "${chalk.bold(siteData.name)}"`)
+    log(`         Verify this siteID "${siteId}" supplied is correct and proceed.`)
+    log('         To skip this prompt, pass a --force flag to the delete command')
+    log()
+    log(`${chalk.bold('Be careful here. There is no undo!')}`)
+    log()
+    const { wantsToDelete } = await inquirer.prompt({
+      type: 'confirm',
+      name: 'wantsToDelete',
+      message: `WARNING: Are you sure you want to delete the "${siteData.name}" site?`,
+      default: false,
+    })
+    log()
+    if (!wantsToDelete) {
+      exit()
+    }
+  }
+
+  /* Validation logic if siteId passed in does not match current site ID */
+  if (noForce && cwdSiteId && cwdSiteId !== siteId) {
+    log(`${chalk.redBright('Warning')}: The siteId supplied does not match the current working directory siteId`)
+    log()
+    log(`Supplied:       "${siteId}"`)
+    log(`Current Site:   "${cwdSiteId}"`)
+    log()
+    log(`Verify this siteID "${siteId}" supplied is correct and proceed.`)
+    log('To skip this prompt, pass a --force flag to the delete command')
+    const { wantsToDelete } = await inquirer.prompt({
+      type: 'confirm',
+      name: 'wantsToDelete',
+      message: `Verify & Proceed with deletion of site "${siteId}"?`,
+      default: false,
+    })
+    if (!wantsToDelete) {
+      exit()
+    }
+  }
+
+  log(`Deleting site "${siteId}"...`)
+
+  try {
+    await api.deleteSite({ site_id: siteId })
+  } catch (error_) {
+    if (error_.status === 404) {
+      error(`No site with id ${siteId} found. Please verify the siteId & try again.`)
+    } else {
+      error(`Delete Site error: ${error_.status}: ${error_.message}`)
+    }
+  }
+  log(`Site "${siteId}" successfully deleted!`)
+}
+
+/**
+ * Creates the `netlify sites:delete` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createSitesDeleteCommand = (program) =>
+  program
+    .command('sites:delete')
+    .description('Delete a site\nThis command will permanently delete the site on Netlify. Use with caution.')
+    .argument('<siteId>', 'Site ID to delete.')
+    .option('-f, --force', 'delete without prompting (useful for CI)')
+    .addExamples(['netlify sites:delete 1234-3262-1211'])
+    .action(sitesDelete)
+
+module.exports = { createSitesDeleteCommand }

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

@@ -0,0 +1,90 @@
+// @ts-check
+
+const { listSites } = require('../../lib/api')
+const { startSpinner, stopSpinner } = require('../../lib/spinner')
+const { chalk, log, logJson } = require('../../utils')
+
+/**
+ * The sites:list command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<{ id: any; name: any; ssl_url: any; account_name: any; }|boolean>}
+ */
+const sitesList = async (options, command) => {
+  const { api } = command.netlify
+  /** @type {import('ora').Ora} */
+  let spinner
+  if (!options.json) {
+    spinner = startSpinner({ text: 'Loading your sites' })
+  }
+  await command.authenticate()
+
+  const sites = await listSites({ api, options: { filter: 'all' } })
+  if (!options.json) {
+    stopSpinner({ spinner })
+  }
+
+  if (sites && sites.length !== 0) {
+    const logSites = sites.map((site) => {
+      const siteInfo = {
+        id: site.id,
+        name: site.name,
+        ssl_url: site.ssl_url,
+        account_name: site.account_name,
+      }
+
+      if (site.build_settings && site.build_settings.repo_url) {
+        siteInfo.repo_url = site.build_settings.repo_url
+      }
+
+      return siteInfo
+    })
+
+    // Json response for piping commands
+    if (options.json) {
+      const redactedSites = sites.map((site) => {
+        if (site && site.build_settings) {
+          delete site.build_settings.env
+        }
+        return site
+      })
+      logJson(redactedSites)
+      return false
+    }
+
+    log(`
+────────────────────────────┐
+ Current Netlify Sites    │
+────────────────────────────┘
+
+Count: ${logSites.length}
+`)
+
+    logSites.forEach((logSite) => {
+      log(`${chalk.greenBright(logSite.name)} - ${logSite.id}`)
+      log(`  ${chalk.whiteBright.bold('url:')}  ${chalk.yellowBright(logSite.ssl_url)}`)
+      if (logSite.repo_url) {
+        log(`  ${chalk.whiteBright.bold('repo:')} ${chalk.white(logSite.repo_url)}`)
+      }
+      if (logSite.account_name) {
+        log(`  ${chalk.whiteBright.bold('account:')} ${chalk.white(logSite.account_name)}`)
+      }
+      log(`─────────────────────────────────────────────────`)
+    })
+  }
+}
+
+/**
+ * Creates the `netlify sites:list` command
+ * @param {import('../base-command').BaseCommand} program
+ */
+const createSitesListCommand = (program) =>
+  program
+    .command('sites:list')
+    .description('List all sites you have access to')
+    .option('--json', 'Output site data as JSON')
+    .action(async (options, command) => {
+      await sitesList(options, command)
+    })
+
+module.exports = { createSitesListCommand }

package/src/commands/sites/sites.js

@@ -0,0 +1,32 @@
+// @ts-check
+const { createSitesCreateCommand } = require('./sites-create')
+const { createSitesDeleteCommand } = require('./sites-delete')
+const { createSitesListCommand } = require('./sites-list')
+
+/**
+ * The sites command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const sites = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify sites` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createSitesCommand = (program) => {
+  createSitesCreateCommand(program)
+  createSitesListCommand(program)
+  createSitesDeleteCommand(program)
+
+  return program
+    .command('sites')
+    .description(`Handle various site operations\nThe sites command will help you manage all your sites`)
+    .addExamples(['netlify sites:create --name my-new-site', 'netlify sites:list'])
+    .action(sites)
+}
+
+module.exports = { createSitesCommand }

package/src/commands/status/index.js

@@ -1,120 +1,5 @@
-const { flags: flagsLib } = require('@oclif/command')
-const chalk = require('chalk')
-const clean = require('clean-deep')
-const prettyjson = require('prettyjson')
+const { createStatusCommand } = require('./status')
 
-const Command = require('../../utils/command')
-const { error, exit, getToken, log, logJson, warn } = require('../../utils/command-helpers')
-
-class StatusCommand extends Command {
-  async run() {
-    const { api, globalConfig, site } = this.netlify
-    const { flags } = this.parse(StatusCommand)
-
-    const current = globalConfig.get('userId')
-    const [accessToken] = await getToken()
-
-    if (!accessToken) {
-      log(`Not logged in. Please log in to see site status.`)
-      log()
-      log('Login with "netlify login" command')
-      exit()
-    }
-
-    const siteId = site.id
-
-    log(`──────────────────────┐
- Current Netlify User │
-──────────────────────┘`)
-
-    let accounts
-    let user
-
-    try {
-      ;[accounts, user] = await Promise.all([api.listAccountsForUser(), api.getCurrentUser()])
-    } catch (error_) {
-      if (error_.status === 401) {
-        error(
-          'Your session has expired. Please try to re-authenticate by running `netlify logout` and `netlify login`.',
-        )
-      }
-    }
-
-    const ghuser = this.netlify.globalConfig.get(`users.${current}.auth.github.user`)
-    const accountData = {
-      Name: user.full_name,
-      Email: user.email,
-      GitHub: ghuser,
-    }
-    const teamsData = {}
-
-    accounts.forEach((team) => {
-      teamsData[team.name] = team.roles_allowed.join(' ')
-    })
-
-    accountData.Teams = teamsData
-
-    const cleanAccountData = clean(accountData)
-
-    log(prettyjson.render(cleanAccountData))
-
-    if (!siteId) {
-      warn('Did you run `netlify link` yet?')
-      error(`You don't appear to be in a folder that is linked to a site`)
-    }
-    let siteData
-    try {
-      siteData = await api.getSite({ siteId })
-    } catch (error_) {
-      // unauthorized
-      if (error_.status === 401) {
-        warn(`Log in with a different account or re-link to a site you have permission for`)
-        error(`Not authorized to view the currently linked site (${siteId})`)
-      }
-      // missing
-      if (error_.status === 404) {
-        error(`The site this folder is linked to can't be found`)
-      }
-      error(error_)
-    }
-
-    // Json only logs out if --json flag is passed
-    if (flags.json) {
-      logJson({
-        account: cleanAccountData,
-        siteData: {
-          'site-name': `${siteData.name}`,
-          'config-path': site.configPath,
-          'admin-url': siteData.admin_url,
-          'site-url': siteData.ssl_url || siteData.url,
-          'site-id': siteData.id,
-        },
-      })
-    }
-
-    log(`────────────────────┐
- Netlify Site Info  │
-────────────────────┘`)
-    log(
-      prettyjson.render({
-        'Current site': `${siteData.name}`,
-        'Netlify TOML': site.configPath,
-        'Admin URL': chalk.magentaBright(siteData.admin_url),
-        'Site URL': chalk.cyanBright(siteData.ssl_url || siteData.url),
-        'Site Id': chalk.yellowBright(siteData.id),
-      }),
-    )
-    log()
-  }
+module.exports = {
+  createStatusCommand,
 }
-
-StatusCommand.description = `Print status information`
-
-StatusCommand.flags = {
-  verbose: flagsLib.boolean({
-    description: 'Output system info',
-  }),
-  ...StatusCommand.flags,
-}
-
-module.exports = StatusCommand

package/src/commands/status/status-hooks.js

@@ -0,0 +1,69 @@
+// @ts-check
+const { get } = require('dot-prop')
+const prettyjson = require('prettyjson')
+
+const { error, log, warn } = require('../../utils')
+
+/**
+ * The status:hooks command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const statusHooks = async (options, command) => {
+  const { api, site } = command.netlify
+
+  await command.authenticate()
+
+  const siteId = site.id
+  if (!siteId) {
+    warn('Did you run `netlify link` yet?')
+    error(`You don't appear to be in a folder that is linked to a site`)
+  }
+
+  let siteData
+  try {
+    siteData = await api.getSite({ siteId })
+  } catch (error_) {
+    // unauthorized
+    if (error_.status === 401) {
+      warn(`Log in with a different account or re-link to a site you have permission for`)
+      error(`Not authorized to view the currently linked site (${siteId})`)
+    }
+    // missing
+    if (error_.status === 404) {
+      error(`The site this folder is linked to can't be found`)
+    }
+    error(error_)
+  }
+
+  const ntlHooks = await api.listHooksBySiteId({ siteId: siteData.id })
+  const data = {
+    site: siteData.name,
+    hooks: {},
+  }
+  ntlHooks.forEach((hook) => {
+    data.hooks[hook.id] = {
+      type: hook.type,
+      event: hook.event,
+      id: hook.id,
+      disabled: hook.disabled,
+    }
+    if (get(siteData, 'build_settings.repo_url')) {
+      data.hooks[hook.id].repo_url = get(siteData, 'build_settings.repo_url')
+    }
+  })
+  log(`─────────────────┐
+Site Hook Status │
+─────────────────┘`)
+  log(prettyjson.render(data))
+}
+
+/**
+ * Creates the `netlify status:hooks` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createStatusHooksCommand = (program) =>
+  program.command('status:hooks').description('Print hook information of the linked site').action(statusHooks)
+
+module.exports = { createStatusHooksCommand }