netlify-cli 8.1.0 → 8.1.5

package/src/commands/env/unset.js

@@ -1,58 +0,0 @@
-const Command = require('../../utils/command')
-const { log, logJson } = require('../../utils/command-helpers')
-
-class EnvUnsetCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(EnvUnsetCommand)
-    const { api, site } = this.netlify
-    const siteId = site.id
-    const { name } = args
-
-    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
-
-    const newEnv = env
-
-    // Delete environment variable from current variables
-    delete newEnv[args.name]
-
-    // 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(`Unset environment variable ${name} for site ${siteData.name}`)
-  }
-}
-
-EnvUnsetCommand.description = `Unset an environment variable which removes it from the UI`
-EnvUnsetCommand.aliases = ['env:delete', 'env:remove']
-EnvUnsetCommand.args = [
-  {
-    name: 'name',
-    required: true,
-    description: 'Environment variable name',
-  },
-]
-
-module.exports = EnvUnsetCommand

package/src/commands/functions/build.js

@@ -1,60 +0,0 @@
-const fs = require('fs')
-
-const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
-const { flags: flagsLib } = require('@oclif/command')
-
-const Command = require('../../utils/command')
-const { exit, log } = require('../../utils/command-helpers')
-const { getFunctionsDir } = require('../../utils/functions')
-const { NETLIFYDEVERR, NETLIFYDEVLOG } = require('../../utils/logo')
-
-class FunctionsBuildCommand extends Command {
-  run() {
-    const { flags } = this.parse(FunctionsBuildCommand)
-
-    const { config } = this.netlify
-
-    const src = flags.src || config.build.functionsSource
-    const dst = getFunctionsDir({ flags, config })
-
-    if (src === dst) {
-      log(`${NETLIFYDEVERR} Source and destination for function build can't be the same`)
-      exit(1)
-    }
-
-    if (!src || !dst) {
-      if (!src)
-        log(
-          `${NETLIFYDEVERR} Error: You must specify a source folder with a --src flag or a functionsSource field in your config`,
-        )
-      if (!dst)
-        log(
-          `${NETLIFYDEVERR} Error: You must specify a destination functions folder with a --functions flag or a functions field in your config`,
-        )
-      exit(1)
-    }
-
-    fs.mkdirSync(dst, { recursive: true })
-
-    log(`${NETLIFYDEVLOG} Building functions`)
-    zipFunctions(src, dst, { skipGo: true })
-    log(`${NETLIFYDEVLOG} Functions built to `, dst)
-  }
-}
-
-FunctionsBuildCommand.description = `Build functions locally
-`
-FunctionsBuildCommand.aliases = ['function:build']
-FunctionsBuildCommand.flags = {
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'Specify a functions directory to build to',
-  }),
-  src: flagsLib.string({
-    char: 's',
-    description: 'Specify the source directory for the functions',
-  }),
-  ...FunctionsBuildCommand.flags,
-}
-
-module.exports = FunctionsBuildCommand

package/src/commands/functions/invoke.js

@@ -1,277 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const process = require('process')
-
-const { flags: flagsLib } = require('@oclif/command')
-const chalk = require('chalk')
-const inquirer = require('inquirer')
-const fetch = require('node-fetch')
-
-const Command = require('../../utils/command')
-const { error } = require('../../utils/command-helpers')
-const { BACKGROUND, getFunctions } = require('../../utils/get-functions')
-const { NETLIFYDEVWARN } = require('../../utils/logo')
-
-// https://www.netlify.com/docs/functions/#event-triggered-functions
-const events = [
-  'deploy-building',
-  'deploy-succeeded',
-  'deploy-failed',
-  'deploy-locked',
-  'deploy-unlocked',
-  'split-test-activated',
-  'split-test-deactivated',
-  'split-test-modified',
-  'submission-created',
-  'identity-validate',
-  'identity-signup',
-  'identity-login',
-]
-const eventTriggeredFunctions = new Set([...events, ...events.map((name) => `${name}${BACKGROUND}`)])
-
-const DEFAULT_PORT = 8888
-
-class FunctionsInvokeCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(FunctionsInvokeCommand)
-
-    const { config } = this.netlify
-
-    const functionsDir = flags.functions || (config.dev && config.dev.functions) || config.functionsDirectory
-    if (typeof functionsDir === 'undefined') {
-      error('functions directory is undefined, did you forget to set it in netlify.toml?')
-    }
-
-    if (!flags.port)
-      console.warn(
-        `${NETLIFYDEVWARN} "port" flag was not specified. Attempting to connect to localhost:8888 by default`,
-      )
-    const port = flags.port || DEFAULT_PORT
-
-    const functions = await getFunctions(functionsDir)
-    const functionToTrigger = await getNameFromArgs(functions, args, flags)
-
-    let headers = {}
-    let body = {}
-
-    if (eventTriggeredFunctions.has(functionToTrigger)) {
-      /** handle event triggered fns  */
-      // https://www.netlify.com/docs/functions/#event-triggered-functions
-      const [name, event] = functionToTrigger.split('-')
-      if (name === 'identity') {
-        // https://www.netlify.com/docs/functions/#identity-event-functions
-        body.event = event
-        body.user = {
-          id: '1111a1a1-a11a-1111-aa11-aaa11111a11a',
-          aud: '',
-          role: '',
-          email: 'foo@trust-this-company.com',
-          app_metadata: {
-            provider: 'email',
-          },
-          user_metadata: {
-            full_name: 'Test Person',
-          },
-          created_at: new Date(Date.now()).toISOString(),
-          update_at: new Date(Date.now()).toISOString(),
-        }
-      } else {
-        // non identity functions seem to have a different shape
-        // https://www.netlify.com/docs/functions/#event-function-payloads
-        body.payload = {
-          TODO: 'mock up payload data better',
-        }
-        body.site = {
-          TODO: 'mock up site data better',
-        }
-      }
-    } else {
-      // NOT an event triggered function, but may still want to simulate authentication locally
-      let isAuthenticated = false
-      if (typeof flags.identity === 'undefined') {
-        const { isAuthed } = await inquirer.prompt([
-          {
-            type: 'confirm',
-            name: 'isAuthed',
-            message: `Invoke with emulated Netlify Identity authentication headers? (pass --identity/--no-identity to override)`,
-            default: true,
-          },
-        ])
-        isAuthenticated = isAuthed
-      } else {
-        isAuthenticated = flags.identity
-      }
-      if (isAuthenticated) {
-        headers = {
-          authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJuZXRsaWZ5IGZ1bmN0aW9uczp0cmlnZ2VyIiwidGVzdERhdGEiOiJORVRMSUZZX0RFVl9MT0NBTExZX0VNVUxBVEVEX0pXVCJ9.Xb6vOFrfLUZmyUkXBbCvU4bM7q8tPilF0F03Wupap_c',
-        }
-        // you can decode this https://jwt.io/
-        // {
-        //   "source": "netlify functions:trigger",
-        //   "testData": "NETLIFY_DEV_LOCALLY_EMULATED_JWT"
-        // }
-      }
-    }
-    const payload = processPayloadFromFlag(flags.payload)
-    body = { ...body, ...payload }
-
-    try {
-      const response = await fetch(
-        `http://localhost:${port}/.netlify/functions/${functionToTrigger}${formatQstring(flags.querystring)}`,
-        {
-          method: 'post',
-          headers,
-          body: JSON.stringify(body),
-        },
-      )
-      const data = await response.text()
-      console.log(data)
-    } catch (error_) {
-      error(`Ran into an error invoking your function: ${error_.message}`)
-    }
-  }
-}
-
-const formatQstring = function (querystring) {
-  if (querystring) {
-    return `?${querystring}`
-  }
-  return ''
-}
-
-/** process payloads from flag */
-const processPayloadFromFlag = function (payloadString) {
-  if (payloadString) {
-    // case 1: jsonstring
-    let payload = tryParseJSON(payloadString)
-    if (payload) return payload
-    // case 2: jsonpath
-    const payloadpath = path.join(process.cwd(), payloadString)
-    const pathexists = fs.existsSync(payloadpath)
-    if (pathexists) {
-      try {
-        // there is code execution potential here
-        // eslint-disable-next-line node/global-require, import/no-dynamic-require
-        payload = require(payloadpath)
-        return payload
-      } catch (error_) {
-        console.error(error_)
-      }
-    }
-    // case 3: invalid string, invalid path
-    return false
-  }
-}
-
-// prompt for a name if name not supplied
-// also used in functions:create
-const getNameFromArgs = async function (functions, args, flags) {
-  const functionToTrigger = getFunctionToTrigger(args, flags)
-  const functionNames = functions.map(getFunctionName)
-
-  if (functionToTrigger) {
-    if (functionNames.includes(functionToTrigger)) {
-      return functionToTrigger
-    }
-
-    console.warn(
-      `Function name ${chalk.yellow(
-        functionToTrigger,
-      )} supplied but no matching function found in your functions folder, forcing you to pick a valid one...`,
-    )
-  }
-
-  const { trigger } = await inquirer.prompt([
-    {
-      type: 'list',
-      message: 'Pick a function to trigger',
-      name: 'trigger',
-      choices: functionNames,
-    },
-  ])
-  return trigger
-}
-
-const getFunctionToTrigger = function (args, flags) {
-  if (flags.name) {
-    if (args.name) {
-      console.error('function name specified in both flag and arg format, pick one')
-      process.exit(1)
-    }
-
-    return flags.name
-  }
-
-  return args.name
-}
-
-const getFunctionName = function ({ name }) {
-  return name
-}
-
-FunctionsInvokeCommand.description = `Trigger a function while in netlify dev with simulated data, good for testing function calls including Netlify's Event Triggered Functions`
-FunctionsInvokeCommand.aliases = ['function:trigger']
-
-FunctionsInvokeCommand.examples = [
-  '$ netlify functions:invoke',
-  '$ netlify functions:invoke myfunction',
-  '$ netlify functions:invoke --name myfunction',
-  '$ netlify functions:invoke --name myfunction --identity',
-  '$ netlify functions:invoke --name myfunction --no-identity',
-  `$ netlify functions:invoke myfunction --payload '{"foo": 1}'`,
-  '$ netlify functions:invoke myfunction --querystring "foo=1',
-  '$ netlify functions:invoke myfunction --payload "./pathTo.json"',
-]
-FunctionsInvokeCommand.args = [
-  {
-    name: 'name',
-    description: 'function name to invoke',
-  },
-]
-
-FunctionsInvokeCommand.flags = {
-  name: flagsLib.string({
-    char: 'n',
-    description: 'function name to invoke',
-  }),
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'Specify a functions folder to parse, overriding netlify.toml',
-  }),
-  querystring: flagsLib.string({
-    char: 'q',
-    description: 'Querystring to add to your function invocation',
-  }),
-  payload: flagsLib.string({
-    char: 'p',
-    description: 'Supply POST payload in stringified json, or a path to a json file',
-  }),
-  identity: flagsLib.boolean({
-    description: 'simulate Netlify Identity authentication JWT. pass --no-identity to affirm unauthenticated request',
-    allowNo: true,
-  }),
-  port: flagsLib.integer({
-    description: 'Port where netlify dev is accessible. e.g. 8888',
-  }),
-  ...FunctionsInvokeCommand.flags,
-}
-
-module.exports = FunctionsInvokeCommand
-
-// https://stackoverflow.com/questions/3710204/how-to-check-if-a-string-is-a-valid-json-string-in-javascript-without-using-try
-const tryParseJSON = function (jsonString) {
-  try {
-    const parsedValue = JSON.parse(jsonString)
-
-    // Handle non-exception-throwing cases:
-    // Neither JSON.parse(false) or JSON.parse(1234) throw errors, hence the type-checking,
-    // but... JSON.parse(null) returns null, and typeof null === "object",
-    // so we must check for that, too. Thankfully, null is falsey, so this suffices:
-    if (parsedValue && typeof parsedValue === 'object') {
-      return parsedValue
-    }
-  } catch {}
-
-  return false
-}

package/src/commands/functions/list.js

@@ -1,102 +0,0 @@
-const process = require('process')
-
-const { flags: flagsLib } = require('@oclif/command')
-const AsciiTable = require('ascii-table')
-
-const Command = require('../../utils/command')
-const { error, exit, log, logJson, warn } = require('../../utils/command-helpers')
-const { getFunctionsDir } = require('../../utils/functions')
-const { getFunctions } = require('../../utils/get-functions')
-
-class FunctionsListCommand extends Command {
-  async run() {
-    const { flags } = this.parse(FunctionsListCommand)
-
-    const { api, config, site } = this.netlify
-
-    // get deployed site details
-    // copied from `netlify status`
-    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 deploy = siteData.published_deploy || {}
-    const deployedFunctions = deploy.available_functions || []
-
-    const functionsDir = getFunctionsDir({ flags, config })
-
-    if (typeof functionsDir === 'undefined') {
-      log('Functions directory is undefined')
-      log('Please verify functions.directory is set in your Netlify configuration file (netlify.toml/yml/json)')
-      log('See https://docs.netlify.com/configure-builds/file-based-configuration/ for more information')
-      process.exit(1)
-    }
-
-    const functions = await getFunctions(functionsDir)
-    const normalizedFunctions = functions.map(normalizeFunction.bind(null, deployedFunctions))
-
-    if (normalizedFunctions.length === 0) {
-      log(`No functions found in ${functionsDir}`)
-      exit()
-    }
-
-    if (flags.json) {
-      logJson(normalizedFunctions)
-      exit()
-    }
-
-    // Make table
-    log(`Based on local functions folder ${functionsDir}, these are the functions detected`)
-    const table = new AsciiTable(`Netlify Functions (in local functions folder)`)
-    table.setHeading('Name', 'URL', 'deployed')
-    normalizedFunctions.forEach(({ isDeployed, name, url }) => {
-      table.addRow(name, url, isDeployed ? 'yes' : 'no')
-    })
-    log(table.toString())
-  }
-}
-
-const normalizeFunction = function (deployedFunctions, { name, urlPath: url }) {
-  const isDeployed = deployedFunctions.some((deployedFunction) => deployedFunction.n === name)
-  return { name, url, isDeployed }
-}
-
-FunctionsListCommand.description = `List functions that exist locally
-
-Helpful for making sure that you have formatted your functions correctly
-
-NOT the same as listing the functions that have been deployed. For that info you need to go to your Netlify deploy log.
-`
-FunctionsListCommand.aliases = ['function:list']
-FunctionsListCommand.flags = {
-  name: flagsLib.string({
-    char: 'n',
-    description: 'name to print',
-  }),
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'Specify a functions directory to list',
-  }),
-  json: flagsLib.boolean({
-    description: 'Output function data as JSON',
-  }),
-  ...FunctionsListCommand.flags,
-}
-
-module.exports = FunctionsListCommand

package/src/commands/functions/serve.js

@@ -1,70 +0,0 @@
-const { join } = require('path')
-
-const { flags: flagsLib } = require('@oclif/command')
-
-const { startFunctionsServer } = require('../../lib/functions/server')
-const Command = require('../../utils/command')
-const { acquirePort, getSiteInformation, injectEnvVariables } = require('../../utils/dev')
-const { getFunctionsDir } = require('../../utils/functions')
-
-const DEFAULT_PORT = 9999
-
-class FunctionsServeCommand extends Command {
-  async run() {
-    const { flags } = this.parse(FunctionsServeCommand)
-
-    const { netlify } = this
-    const { api, config, site, siteInfo } = netlify
-
-    const functionsDir = getFunctionsDir({ flags, config }, join('netlify', 'functions'))
-
-    await injectEnvVariables({ env: this.netlify.cachedConfig.env, site })
-
-    const { capabilities, siteUrl, timeouts } = await getSiteInformation({
-      flags,
-      api,
-      site,
-      siteInfo,
-    })
-
-    const functionsPort = await acquirePort({
-      configuredPort: flags.port || (config.dev && config.dev.functionsPort),
-      defaultPort: DEFAULT_PORT,
-      errorMessage: 'Could not acquire configured functions port',
-    })
-
-    await startFunctionsServer({
-      config,
-      settings: { functions: functionsDir, functionsPort },
-      site,
-      siteUrl,
-      capabilities,
-      timeouts,
-      functionsPrefix: '/.netlify/functions/',
-      buildersPrefix: '/.netlify/builders/',
-    })
-  }
-}
-
-FunctionsServeCommand.description = `(Beta) Serve functions locally
-
-Helpful for debugging functions.
-`
-FunctionsServeCommand.aliases = ['function:serve']
-FunctionsServeCommand.flags = {
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'Specify a functions directory to serve',
-  }),
-  port: flagsLib.integer({
-    char: 'p',
-    description: 'Specify a port for the functions server',
-  }),
-  offline: flagsLib.boolean({
-    char: 'o',
-    description: 'disables any features that require network access',
-  }),
-  ...FunctionsServeCommand.flags,
-}
-
-module.exports = FunctionsServeCommand

package/src/commands/link.js

@@ -1,133 +0,0 @@
-const path = require('path')
-const process = require('process')
-
-const { flags: flagsLib } = require('@oclif/command')
-const chalk = require('chalk')
-
-const { listSites } = require('../lib/api')
-const Command = require('../utils/command')
-const { error, exit, log } = require('../utils/command-helpers')
-const ensureNetlifyIgnore = require('../utils/gitignore')
-const linkPrompt = require('../utils/link/link-by-prompt')
-const { track } = require('../utils/telemetry')
-
-class LinkCommand extends Command {
-  async run() {
-    await this.authenticate()
-
-    const { flags } = this.parse(LinkCommand)
-    const {
-      api,
-      repositoryRoot,
-      site: { id: siteId },
-      state,
-    } = this.netlify
-
-    let siteData
-    try {
-      siteData = await api.getSite({ siteId })
-    } catch {
-      // silent api error
-    }
-
-    // Add .netlify to .gitignore file
-    await ensureNetlifyIgnore(repositoryRoot)
-
-    // Site id is incorrect
-    if (siteId && !siteData) {
-      console.log(`"${siteId}" was not found in your Netlify account.`)
-      console.log(`Please double check your siteID and which account you are logged into via \`netlify status\`.`)
-      return exit()
-    }
-
-    // If already linked to site. exit and prompt for unlink
-    if (siteData) {
-      log(`Site already linked to "${siteData.name}"`)
-      log(`Admin url: ${siteData.admin_url}`)
-      log()
-      log(`To unlink this site, run: ${chalk.cyanBright('netlify unlink')}`)
-      return exit()
-    }
-
-    if (flags.id) {
-      try {
-        siteData = await api.getSite({ site_id: flags.id })
-      } catch (error_) {
-        if (error_.status === 404) {
-          error(new Error(`Site id ${flags.id} not found`))
-        } else {
-          error(error_)
-        }
-      }
-
-      // Save site ID
-      state.set('siteId', siteData.id)
-      log(`Linked to ${siteData.name} in ${state.path}`)
-
-      await track('sites_linked', {
-        siteId: siteData.id,
-        linkType: 'manual',
-        kind: 'byId',
-      })
-
-      return exit()
-    }
-
-    if (flags.name) {
-      let results
-      try {
-        results = await listSites({
-          api,
-          options: {
-            name: flags.name,
-            filter: 'all',
-          },
-        })
-      } catch (error_) {
-        if (error_.status === 404) {
-          error(new Error(`${flags.name} not found`))
-        } else {
-          error(error_)
-        }
-      }
-
-      if (results.length === 0) {
-        error(new Error(`No sites found named ${flags.name}`))
-      }
-      const [firstSiteData] = results
-      state.set('siteId', firstSiteData.id)
-
-      log(`Linked to ${firstSiteData.name} in ${path.relative(path.join(process.cwd(), '..'), state.path)}`)
-
-      await track('sites_linked', {
-        siteId: (firstSiteData && firstSiteData.id) || siteId,
-        linkType: 'manual',
-        kind: 'byName',
-      })
-
-      return exit()
-    }
-
-    siteData = await linkPrompt(this, flags)
-    return siteData
-  }
-}
-
-LinkCommand.description = `Link a local repo or project folder to an existing site on Netlify`
-
-LinkCommand.examples = ['netlify link', 'netlify link --id 123-123-123-123', 'netlify link --name my-site-name']
-
-LinkCommand.flags = {
-  id: flagsLib.string({
-    description: 'ID of site to link to',
-  }),
-  name: flagsLib.string({
-    description: 'Name of site to link to',
-  }),
-  gitRemoteName: flagsLib.string({
-    description: 'Name of Git remote to use. e.g. "origin"',
-  }),
-  ...LinkCommand.flags,
-}
-
-module.exports = LinkCommand