netlify-cli 8.0.7 → 8.1.0-rc

package/src/commands/api/api.js

@@ -0,0 +1,83 @@
+// @ts-check
+const AsciiTable = require('ascii-table')
+
+// TODO: use static `import` after migrating this repository to pure ES modules
+const jsClient = import('netlify')
+
+const { chalk, error, exit, generateDescriptionHelp, generateExamplesHelp, log, logJson } = require('../../utils')
+
+/**
+ * The api command
+ * @param {string} apiMethod
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const apiCommand = async (apiMethod, options, command) => {
+  const { api } = command.netlify
+
+  if (options.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 (options.data) {
+    payload = typeof options.data === 'string' ? JSON.parse(options.data) : options.data
+  } else {
+    payload = {}
+  }
+  try {
+    const apiResponse = await api[apiMethod](payload)
+    logJson(apiResponse)
+  } catch (error_) {
+    error(error_)
+  }
+}
+
+/**
+ * Creates the `netlify api` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createApiCommand = (program) =>
+  program
+    .command('api')
+    .argument('[method]', 'Open API method to run')
+    .option('-d, --data <data>', 'Data to use')
+    .option('--list', 'List out available API methods', false)
+    .addHelpText(
+      'after',
+      generateDescriptionHelp(
+        `For more information on available methods checkout https://open-api.netlify.com/ or run '${chalk.grey(
+          'netlify api --list',
+        )}'`,
+      ),
+    )
+    .addHelpText(
+      'after',
+      generateExamplesHelp([
+        'netlify api --list',
+        `netlify api getSite --data '${chalk.grey('{ "site_id": "123456"}')}'`,
+      ]),
+    )
+    .action(apiCommand)
+
+module.exports = { createApiCommand }

package/src/commands/api/index.js

@@ -0,0 +1,5 @@
+const { createApiCommand } = require('./api')
+
+module.exports = {
+  createApiCommand,
+}

package/src/commands/base-command.js

@@ -0,0 +1,322 @@
+// @ts-check
+const process = require('process')
+const { format } = require('util')
+
+const resolveConfig = require('@netlify/config')
+const { Command } = require('commander')
+const debug = require('debug')
+const merge = require('lodash/merge')
+
+// TODO: use static `import` after migrating this repository to pure ES modules
+const jsClient = import('netlify')
+
+const { getAgent } = require('../lib/http-agent')
+const {
+  StateConfig,
+  USER_AGENT,
+  chalk,
+  error,
+  exit,
+  getGlobalConfig,
+  getToken,
+  identify,
+  log,
+  normalizeConfig,
+  openBrowser,
+  pollForToken,
+  track,
+} = require('../utils')
+
+// Netlify CLI client id. Lives in bot@netlify.com
+// TODO: setup client for multiple environments
+const CLIENT_ID = 'd6f37de6614df7ae58664cfca524744d73807a377f5ee71f1a254f78412e3750'
+
+const NANO_SECS_TO_MSECS = 1e6
+
+/**
+ * Get the duration between a start time and the current time
+ * @param {bigint} startTime
+ * @returns
+ */
+const getDuration = function (startTime) {
+  const durationNs = process.hrtime.bigint() - startTime
+  return Math.round(Number(durationNs / BigInt(NANO_SECS_TO_MSECS)))
+}
+
+/**
+ * The netlify object inside each command with the state
+ * @typedef NetlifyOptions
+ * @type {object}
+ * @property {import('netlify').NetlifyAPI} api
+ * @property {*} repositoryRoot
+ * @property {object} site
+ * @property {*} site.root
+ * @property {*} site.configPath
+ * @property {*} site.id
+ * @property {*} siteInfo
+ * @property {*} config
+ * @property {*} cachedConfig
+ * @property {*} globalConfig
+ * @property {StateConfig} state,
+ */
+
+/** Base command class that provides tracking and config initialization */
+class BaseCommand extends Command {
+  /** @type {NetlifyOptions} */
+  netlify
+
+  /** @type {{ startTime: bigint, payload?: any}} */
+  analytics = { startTime: process.hrtime.bigint() }
+
+  /**
+   * IMPORTANT this function will be called for each command!
+   * Don't do anything expensive in there.
+   * @param {string} name The command name
+   * @returns
+   */
+  createCommand(name) {
+    return (
+      new BaseCommand(name)
+        // If  --silent or --json flag passed disable logger
+        .option('--json')
+        .option('--cwd <cwd>', 'Pass a current working directory.')
+        .option('-o, --offline')
+
+        // Allow hidden flags like
+        // --json,
+        // --silent,
+        // --offline, -o
+        // --cwd <cwd> Pass a current working directory.
+
+        // this disables the suggestions
+        // .allowUnknownOption(true)
+
+        .option('--debug', 'Print debugging information')
+        .option(
+          '--httpProxy',
+          'Proxy server address to route requests through',
+          process.env.HTTP_PROXY || process.env.HTTPS_PROXY,
+        )
+        .option(
+          '--httpProxyCertificateFilename',
+          'Certificate file to use when connecting using a proxy server',
+          process.env.NETLIFY_PROXY_CERTIFICATE_FILENAME,
+        )
+        .hook('preAction', async (_parentCommand, actionCommand) => {
+          debug(`${name}:preAction`)('start')
+          this.analytics = { startTime: process.hrtime.bigint() }
+          // @ts-ignore cannot type actionCommand as BaseCommand
+          await this.init(actionCommand)
+          debug(`${name}:preAction`)('end')
+        })
+    )
+  }
+
+  /**
+   * Will be called on the end of an action to track the metrics
+   * @param {*} [error_]
+   */
+  async onEnd(error_) {
+    const { payload, startTime } = this.analytics
+    const duration = getDuration(startTime)
+    const status = error_ === undefined ? 'success' : 'error'
+
+    debug(`${this.name()}:onEnd`)(`Status: ${status}`)
+    debug(`${this.name()}:onEnd`)(`Duration: ${duration}ms`)
+
+    await track('command', {
+      ...payload,
+      command: this.name(),
+      duration,
+      status,
+    })
+
+    if (error_ !== undefined) {
+      error(error_ instanceof Error ? error_ : format(error_), { exit: false })
+      exit(1)
+    }
+  }
+
+  async authenticate(tokenFromFlag) {
+    const [token] = await getToken(tokenFromFlag)
+    if (token) {
+      return token
+    }
+    return this.expensivelyAuthenticate()
+  }
+
+  async expensivelyAuthenticate() {
+    const webUI = process.env.NETLIFY_WEB_UI || 'https://app.netlify.com'
+    log(`Logging into your Netlify account...`)
+
+    // Create ticket for auth
+    // @ts-ignore Types from api are wrong and they don't recognize `createTicket`
+    const ticket = await this.netlify.api.createTicket({
+      clientId: CLIENT_ID,
+    })
+
+    // Open browser for authentication
+    const authLink = `${webUI}/authorize?response_type=ticket&ticket=${ticket.id}`
+
+    log(`Opening ${authLink}`)
+    await openBrowser({ url: authLink })
+
+    const accessToken = await pollForToken({
+      api: this.netlify.api,
+      ticket,
+    })
+
+    // @ts-ignore Types from api are wrong and they don't recognize `getCurrentUser`
+    const { email, full_name: name, id: userId } = await this.netlify.api.getCurrentUser()
+
+    const userData = merge(this.netlify.globalConfig.get(`users.${userId}`), {
+      id: userId,
+      name,
+      email,
+      auth: {
+        token: accessToken,
+        github: {
+          user: undefined,
+          token: undefined,
+        },
+      },
+    })
+    // Set current userId
+    this.netlify.globalConfig.set('userId', userId)
+    // Set user data
+    this.netlify.globalConfig.set(`users.${userId}`, userData)
+
+    await identify({
+      name,
+      email,
+      userId,
+    })
+    await track('user_login', {
+      email,
+    })
+
+    // Log success
+    log()
+    log(`${chalk.greenBright('You are now logged into your Netlify account!')}`)
+    log()
+    log(`Run ${chalk.cyanBright('netlify status')} for account details`)
+    log()
+    log(`To see all available commands run: ${chalk.cyanBright('netlify help')}`)
+    log()
+    return accessToken
+  }
+
+  setAnalyticsPayload(payload) {
+    this.analytics = { ...this.analytics, payload }
+  }
+
+  /**
+   * Initializes the options and parses the configuration needs to be called on start of a command function
+   * @param {BaseCommand} actionCommand The command of the action that is run (`this.` gets the parent command)
+   */
+  async init(actionCommand) {
+    debug(`${actionCommand.name()}:init`)('start')
+    const options = actionCommand.opts()
+    const cwd = options.cwd || process.cwd()
+    // Get site id & build state
+    const state = new StateConfig(cwd)
+
+    const [token] = await getToken(options.auth)
+
+    const apiUrlOpts = {
+      userAgent: USER_AGENT,
+    }
+
+    if (process.env.NETLIFY_API_URL) {
+      const apiUrl = new URL(process.env.NETLIFY_API_URL)
+      apiUrlOpts.scheme = apiUrl.protocol.slice(0, -1)
+      apiUrlOpts.host = apiUrl.host
+      apiUrlOpts.pathPrefix =
+        process.env.NETLIFY_API_URL === `${apiUrl.protocol}//${apiUrl.host}` ? '/api/v1' : apiUrl.pathname
+    }
+
+    const cachedConfig = await actionCommand.getConfig({ cwd, state, token, ...apiUrlOpts })
+    const { buildDir, config, configPath, repositoryRoot, siteInfo } = cachedConfig
+    const normalizedConfig = normalizeConfig(config)
+
+    const agent = await getAgent({
+      httpProxy: options.httpProxy,
+      certificateFile: options.httpProxyCertificateFilename,
+    })
+    const apiOpts = { ...apiUrlOpts, agent }
+    const globalConfig = await getGlobalConfig()
+    const { NetlifyAPI } = await jsClient
+
+    actionCommand.netlify = {
+      // api methods
+      api: new NetlifyAPI(token || '', apiOpts),
+      repositoryRoot,
+      // current site context
+      site: {
+        root: buildDir,
+        configPath,
+        get id() {
+          return state.get('siteId')
+        },
+        set id(id) {
+          state.set('siteId', id)
+        },
+      },
+      // Site information retrieved using the API
+      siteInfo,
+      // Configuration from netlify.[toml/yml]
+      config: normalizedConfig,
+      // Used to avoid calling @netlify/config again
+      cachedConfig,
+      // global cli config
+      globalConfig,
+      // state of current site dir
+      state,
+    }
+    debug(`${this.name()}:init`)('end')
+  }
+
+  /**
+   * Find and resolve the Netlify configuration
+   * @param {*} config
+   * @returns {ReturnType<import('@netlify/config/src/main')>}
+   */
+  async getConfig(config) {
+    const options = this.opts()
+    const { cwd, host, offline = options.offline, pathPrefix, scheme, state, token } = config
+
+    try {
+      return await resolveConfig({
+        config: options.config,
+        cwd,
+        context: options.context || this.name(),
+        debug: this.opts().debug,
+        siteId: options.siteId || (typeof options.site === 'string' && options.site) || state.get('siteId'),
+        token,
+        mode: 'cli',
+        host,
+        pathPrefix,
+        scheme,
+        offline,
+      })
+    } catch (error_) {
+      const isUserError = error_.customErrorInfo !== undefined && error_.customErrorInfo.type === 'resolveConfig'
+
+      // If we're failing due to an error thrown by us, it might be because the token we're using is invalid.
+      // To account for that, we try to retrieve the config again, this time without a token, to avoid making
+      // any API calls.
+      //
+      // @todo Replace this with a mechanism for calling `resolveConfig` with more granularity (i.e. having
+      // the option to say that we don't need API data.)
+      if (isUserError && !offline && token) {
+        return this.getConfig({ cwd, offline: true, state, token })
+      }
+
+      const message = isUserError ? error_.message : error_.stack
+      console.error(message)
+      exit(1)
+    }
+  }
+}
+
+module.exports = { BaseCommand }

package/src/commands/build/build.js

@@ -0,0 +1,58 @@
+// @ts-check
+const { getBuildOptions, runBuild } = require('../../lib/build')
+const { error, exit, generateExamplesHelp, getToken } = require('../../utils')
+
+/**
+ * @param {import('../../lib/build').BuildConfig} options
+ */
+const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
+  if (!siteInfo.id) {
+    error('Could not find the site ID. Please run netlify link.')
+  }
+
+  if (!token) {
+    error('Could not find the access token. Please run netlify login.')
+  }
+}
+
+/**
+ * The build command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const build = async (options, command) => {
+  command.setAnalyticsPayload({ dry: options.dry })
+
+  // Retrieve Netlify Build options
+  const [token] = await getToken()
+
+  const buildOptions = await getBuildOptions({
+    cachedConfig: command.netlify.cachedConfig,
+    token,
+    options,
+  })
+
+  if (!options.offline) {
+    checkOptions(buildOptions)
+  }
+
+  const { exitCode } = await runBuild(buildOptions)
+  exit(exitCode)
+}
+
+/**
+ * Creates the `netlify build` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createBuildCommand = (program) =>
+  program
+    .command('build')
+    .description('(Beta) Build on your local machine')
+    .option('--dry', 'Dry run: show instructions without running them', false)
+    .option('--context [context]', 'Build context')
+    .option('-o, --offline', 'disables any features that require network access', false)
+    .addHelpText('after', generateExamplesHelp(['netlify build']))
+    .action(build)
+
+module.exports = { createBuildCommand }

package/src/commands/build/index.js

@@ -1,63 +1,5 @@
-const { flags: flagsLib } = require('@oclif/command')
+const { createBuildCommand } = require('./build')
 
-const { getBuildOptions, runBuild } = require('../../lib/build')
-const Command = require('../../utils/command')
-const { error, exit, getToken } = require('../../utils/command-helpers')
-
-const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
-  if (!siteInfo.id) {
-    error('Could not find the site ID. Please run netlify link.', { exit: 1 })
-  }
-
-  if (!token) {
-    error('Could not find the access token. Please run netlify login.', { exit: 1 })
-  }
-}
-
-class BuildCommand extends Command {
-  // Run Netlify Build
-  async run() {
-    const { flags } = this.parse(BuildCommand)
-
-    this.setAnalyticsPayload({ dry: flags.dry })
-
-    // Retrieve Netlify Build options
-    const [token] = await getToken()
-
-    const options = await getBuildOptions({
-      context: this,
-      token,
-      flags,
-    })
-
-    if (!flags.offline) {
-      checkOptions(options)
-    }
-
-    const { exitCode } = await runBuild(options)
-    exit(exitCode)
-  }
-}
-
-// Netlify Build programmatic options
-BuildCommand.flags = {
-  dry: flagsLib.boolean({
-    description: 'Dry run: show instructions without running them',
-    default: false,
-  }),
-  context: flagsLib.string({
-    description: 'Build context',
-  }),
-  offline: flagsLib.boolean({
-    char: 'o',
-    description: 'disables any features that require network access',
-    default: false,
-  }),
-  ...BuildCommand.flags,
+module.exports = {
+  createBuildCommand,
 }
-
-BuildCommand.description = `(Beta) Build on your local machine`
-
-BuildCommand.examples = ['netlify build']
-
-module.exports = BuildCommand

package/src/commands/completion/completion.js

@@ -0,0 +1,18 @@
+/**
+ * The completion command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const completion = (options, command) => {
+  console.log('completion command with options', options, command.name())
+}
+
+/**
+ * Creates the `netlify completion` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createCompletionCommand = (program) =>
+  program.command('completion').description('(Beta) Generate shell completion script').action(completion)
+
+module.exports = { createCompletionCommand }

package/src/commands/completion/index.js

@@ -0,0 +1,5 @@
+const { createCompletionCommand } = require('./completion')
+
+module.exports = {
+  createCompletionCommand,
+}