netlify-cli 9.16.7 → 10.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "9.16.7",
+  "version": "10.1.0",
   "author": "Netlify Inc.",
   "contributors": [
     "Abraham Schilling <AbrahamSchilling@gmail.com> (https://gitlab.com/n4bb12)",
@@ -103,6 +103,7 @@
     "Sam Holmes <samholmes1337@gmail.com> (https://samholmes.net)",
     "Sander de Groot (https://degroot.dev)",
     "Sarah Drasner <sarah.drasner@gmail.com> (https://twitter.com/sarah_edo)",
+    "Sarah Etter <sarah@sarahetter.com> (http://www.sarahetter.com)",
     "Scott Spence <spences10apps@gmail.com> (https://twitter.com/spences10)",
     "Sean Grove <sean@bushi.do> (https://twitter.com/sgrove)",
     "Sebastian Smolorz",
@@ -206,13 +207,12 @@
     "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tools,scripts,site,tests,.github}/**/*.{mjs,cjs,js,md,yml,json,html}\" \"*.{mjs,cjs,js,yml,json,html}\" \".*.{mjs,cjs,js,yml,json,html}\" \"!CHANGELOG.md\" \"!npm-shrinkwrap.json\" \"!**/*/package-lock.json\" \"!.github/**/*.md\""
   },
   "dependencies": {
-    "@netlify/build": "^26.5.3",
-    "@netlify/config": "^17.0.20",
+    "@netlify/build": "^27.0.1",
+    "@netlify/config": "^18.0.0",
+    "@netlify/edge-bundler": "^0.12.0",
     "@netlify/framework-info": "^9.0.2",
     "@netlify/local-functions-proxy": "^1.1.1",
-    "@netlify/plugin-edge-handlers": "^3.0.7",
     "@netlify/plugins-list": "^6.19.0",
-    "@netlify/routing-local-proxy": "^0.34.1",
     "@netlify/zip-it-and-ship-it": "^5.9.0",
     "@octokit/rest": "^18.0.0",
     "@sindresorhus/slugify": "^1.1.0",
@@ -241,6 +241,7 @@
     "dotenv": "^16.0.0",
     "env-paths": "^2.2.0",
     "envinfo": "^7.3.1",
+    "etag": "^1.8.1",
     "execa": "^5.0.0",
     "express": "^4.17.1",
     "express-logging": "^1.1.1",
@@ -310,6 +311,7 @@
     "through2-map": "^3.0.0",
     "to-readable-stream": "^2.1.0",
     "toml": "^3.0.0",
+    "unixify": "^1.0.0",
     "update-notifier": "^5.0.0",
     "uuid": "^8.0.0",
     "wait-port": "^0.2.2",
@@ -329,6 +331,7 @@
     "husky": "^7.0.4",
     "ini": "^2.0.0",
     "mock-fs": "^5.1.2",
+    "nock": "^13.2.4",
     "p-timeout": "^4.0.0",
     "rewiremock": "^3.14.3",
     "seedrandom": "^3.0.5",

package/src/commands/base-command.js

@@ -421,7 +421,6 @@ class BaseCommand extends Command {
     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,
@@ -478,7 +477,7 @@ class BaseCommand extends Command {
           options.context ||
           process.env.CONTEXT ||
           // Dev commands have a default context of `dev`, otherwise we let netlify/config handle default behavior
-          (['dev', 'dev:exec', 'dev:trace'].includes(this.name()) ? 'dev' : undefined),
+          (['dev', 'dev:exec'].includes(this.name()) ? 'dev' : undefined),
         debug: this.opts().debug,
         siteId: options.siteId || (typeof options.site === 'string' && options.site) || state.get('siteId'),
         token,

package/src/commands/deploy/deploy.js

@@ -20,7 +20,6 @@ const {
   NETLIFYDEVERR,
   NETLIFYDEVLOG,
   chalk,
-  deployEdgeHandlers,
   deploySite,
   error,
   exit,
@@ -314,12 +313,6 @@ const runDeploy = async ({
     results = await api.createSiteDeploy({ siteId, title, body: { draft, branch: alias } })
     deployId = results.id
 
-    await deployEdgeHandlers({
-      site,
-      deployId,
-      api,
-      silent,
-    })
     const internalFunctionsFolder = await getInternalFunctionsDir({ base: site.root })
 
     // The order of the directories matter: zip-it-and-ship-it will prioritize

package/src/commands/dev/dev.js

@@ -11,6 +11,7 @@ const StaticServer = require('static-server')
 const stripAnsiCc = require('strip-ansi-control-characters')
 const waitPort = require('wait-port')
 
+const { promptEditorHelper } = require('../../lib/edge-functions')
 const { startFunctionsServer } = require('../../lib/functions/server')
 const {
   OneGraphCliClient,
@@ -42,7 +43,6 @@ const {
   normalizeConfig,
   openBrowser,
   processOnExit,
-  startForwardProxy,
   startLiveTunnel,
   startProxy,
   warn,
@@ -50,7 +50,6 @@ const {
 } = require('../../utils')
 
 const { createDevExecCommand } = require('./dev-exec')
-const { createDevTraceCommand } = require('./dev-trace')
 
 const startStaticServer = async ({ settings }) => {
   const server = new StaticServer({
@@ -198,37 +197,44 @@ const FRAMEWORK_PORT_TIMEOUT = 6e5
 
 /**
  *
- * @param {object} config
- * @param {*} config.addonsUrls
- * @param {import('commander').OptionValues} config.options
- * @param {*} config.settings
- * @param {*} config.site
+ * @param {object} params
+ * @param {*} params.addonsUrls
+ * @param {import('../base-command').NetlifyOptions["config"]} params.config
+ * @param {() => Promise<object>} params.getUpdatedConfig
+ * @param {string} params.geolocationMode
+ * @param {*} params.settings
+ * @param {boolean} params.offline
+ * @param {*} params.site
+ * @param {import('../../utils/state-config').StateConfig} params.state
  * @returns
  */
-const startProxyServer = async ({ addonsUrls, options, settings, site }) => {
-  let url
-  if (options.edgeHandlers || options.trafficMesh) {
-    url = await startForwardProxy({
-      port: settings.port,
-      frameworkPort: settings.frameworkPort,
-      functionsPort: settings.functionsPort,
-      publishDir: settings.dist,
-      debug: options.debug,
-      locationDb: options.locationDb,
-      jwtRolesPath: settings.jwtRolePath,
-      jwtSecret: settings.jwtSecret,
-    })
-    if (!url) {
-      log(NETLIFYDEVERR, `Unable to start forward proxy on port '${settings.port}'`)
-      exit(1)
-    }
-  } else {
-    url = await startProxy(settings, addonsUrls, site.configPath, site.root)
-    if (!url) {
-      log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)
-      exit(1)
-    }
+const startProxyServer = async ({
+  addonsUrls,
+  config,
+  geolocationMode,
+  getUpdatedConfig,
+  offline,
+  settings,
+  site,
+  state,
+}) => {
+  const url = await startProxy({
+    addonsUrls,
+    config,
+    configPath: site.configPath,
+    geolocationMode,
+    getUpdatedConfig,
+    offline,
+    projectDir: site.root,
+    settings,
+    state,
+  })
+
+  if (!url) {
+    log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)
+    exit(1)
   }
+
   return url
 }
 
@@ -313,7 +319,7 @@ const startPollingForAPIAuthentication = async function (options) {
  */
 const dev = async (options, command) => {
   log(`${NETLIFYDEV}`)
-  const { api, config, site, siteInfo, state } = command.netlify
+  const { api, config, repositoryRoot, site, siteInfo, state } = command.netlify
   config.dev = { ...config.dev }
   config.build = { ...config.build }
   /** @type {import('./types').DevConfig} */
@@ -325,13 +331,8 @@ const dev = async (options, command) => {
     ...options,
   }
 
-  if (options.trafficMesh) {
-    warn(
-      '--trafficMesh and -t are deprecated and will be removed in the near future. Please use --edgeHandlers or -e instead.',
-    )
-  }
-
   await injectEnvVariables({ devConfig, env: command.netlify.cachedConfig.env, site })
+  await promptEditorHelper({ chalk, config, log, NETLIFYDEVLOG, repositoryRoot, state })
 
   const { addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
     // inherited from base command --offline
@@ -370,7 +371,25 @@ const dev = async (options, command) => {
   })
   await startFrameworkServer({ settings })
 
-  let url = await startProxyServer({ options, settings, site, addonsUrls })
+  // TODO: We should consolidate this with the existing config watcher.
+  const getUpdatedConfig = async () => {
+    const cwd = options.cwd || process.cwd()
+    const { config: newConfig } = await command.getConfig({ cwd, offline: true, state })
+    const normalizedNewConfig = normalizeConfig(newConfig)
+
+    return normalizedNewConfig
+  }
+
+  let url = await startProxyServer({
+    addonsUrls,
+    config,
+    geolocationMode: options.geo,
+    getUpdatedConfig,
+    offline: options.offline,
+    settings,
+    site,
+    state,
+  })
 
   const liveTunnelUrl = await handleLiveTunnel({ options, site, api, settings })
   url = liveTunnelUrl || url
@@ -474,7 +493,6 @@ const dev = async (options, command) => {
  */
 const createDevCommand = (program) => {
   createDevExecCommand(program)
-  createDevTraceCommand(program)
 
   return program
     .command('dev')
@@ -490,23 +508,18 @@ const createDevCommand = (program) => {
     .option('-o ,--offline', 'disables any features that require network access')
     .option('-l, --live', 'start a public live session', false)
     .option('--functionsPort <port>', 'port of functions server', (value) => Number.parseInt(value))
-    .addOption(
-      new Option('--staticServerPort <port>', 'port of the static app server used when no framework is detected')
-        .argParser((value) => Number.parseInt(value))
-        .hideHelp(),
-    )
-    .addOption(new Option('-e ,--edgeHandlers', 'activates the Edge Handlers runtime').hideHelp())
     .addOption(
       new Option(
-        '-t ,--trafficMesh',
-        '(DEPRECATED: use --edgeHandlers or -e instead) uses Traffic Mesh for proxying requests',
-      ).hideHelp(),
+        '--geo <mode>',
+        'force geolocation data to be updated, use cached data from the last 24h if found, or use a mock location',
+      )
+        .choices(['cache', 'mock', 'update'])
+        .default('cache'),
     )
     .addOption(
-      new Option(
-        '-g ,--locationDb <path>',
-        'specify the path to a local GeoIP location database in MMDB format',
-      ).hideHelp(),
+      new Option('--staticServerPort <port>', 'port of the static app server used when no framework is detected')
+        .argParser((value) => Number.parseInt(value))
+        .hideHelp(),
     )
     .addOption(new Option('--graph', 'enable Netlify Graph support').hideHelp())
     .addExamples([

package/src/commands/main.js

@@ -36,6 +36,7 @@ const { createLmCommand } = require('./lm')
 const { createLoginCommand } = require('./login')
 const { createLogoutCommand } = require('./logout')
 const { createOpenCommand } = require('./open')
+const { createRecipesCommand, createRecipesListCommand } = require('./recipes')
 const { createSitesCommand } = require('./sites')
 const { createStatusCommand } = require('./status')
 const { createSwitchCommand } = require('./switch')
@@ -171,6 +172,8 @@ const createMainCommand = () => {
   createDevCommand(program)
   createEnvCommand(program)
   createFunctionsCommand(program)
+  createRecipesCommand(program)
+  createRecipesListCommand(program)
   createGraphCommand(program)
   createInitCommand(program)
   createLinkCommand(program)

package/src/commands/recipes/common.js

@@ -0,0 +1,33 @@
+const { promises: fs } = require('fs')
+const { join, resolve } = require('path')
+
+const getRecipe = (name) => {
+  const recipePath = resolve(__dirname, '../../recipes', name)
+
+  // eslint-disable-next-line import/no-dynamic-require, n/global-require
+  const recipe = require(recipePath)
+
+  return recipe
+}
+
+const listRecipes = async () => {
+  const recipesPath = resolve(__dirname, '../../recipes')
+  const recipeNames = await fs.readdir(recipesPath)
+  const recipes = await Promise.all(
+    recipeNames.map((name) => {
+      const recipePath = join(recipesPath, name)
+
+      // eslint-disable-next-line import/no-dynamic-require, n/global-require
+      const recipe = require(recipePath)
+
+      return {
+        ...recipe,
+        name,
+      }
+    }),
+  )
+
+  return recipes
+}
+
+module.exports = { getRecipe, listRecipes }

package/src/commands/recipes/index.js

@@ -0,0 +1,8 @@
+const { createRecipesCommand, runRecipe } = require('./recipes')
+const { createRecipesListCommand } = require('./recipes-list')
+
+module.exports = {
+  createRecipesCommand,
+  createRecipesListCommand,
+  runRecipe,
+}

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

@@ -0,0 +1,34 @@
+// @ts-check
+const AsciiTable = require('ascii-table')
+
+const { listRecipes } = require('./common')
+
+/**
+ * The recipes:list command
+ */
+const recipesListCommand = async () => {
+  const recipes = await listRecipes()
+  const table = new AsciiTable(`Usage: netlify recipes <name>`)
+
+  table.setHeading('Name', 'Description')
+
+  recipes.forEach(({ description, name }) => {
+    table.addRow(name, description)
+  })
+
+  console.log(table.toString())
+}
+
+/**
+ * Creates the `netlify recipes:list` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createRecipesListCommand = (program) =>
+  program
+    .command('recipes:list')
+    .description(`(Beta) List the recipes available to create and modify files in a project`)
+    .addExamples(['netlify recipes:list'])
+    .action(recipesListCommand)
+
+module.exports = { createRecipesListCommand }

package/src/commands/recipes/recipes.js

@@ -0,0 +1,85 @@
+// @ts-check
+const { basename } = require('path')
+
+const inquirer = require('inquirer')
+const { findBestMatch } = require('string-similarity')
+
+const utils = require('../../utils/command-helpers')
+
+const { getRecipe, listRecipes } = require('./common')
+
+const SUGGESTION_TIMEOUT = 1e4
+
+/**
+ * The recipes command
+ * @param {string} recipeName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const recipesCommand = async (recipeName, options, command) => {
+  const { config, repositoryRoot } = command.netlify
+  const sanitizedRecipeName = basename(recipeName || '').toLowerCase()
+
+  if (sanitizedRecipeName.length === 0) {
+    return command.help()
+  }
+
+  try {
+    return await runRecipe({ config, recipeName: sanitizedRecipeName, repositoryRoot })
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error
+    }
+
+    utils.log(`${utils.NETLIFYDEVERR} ${utils.chalk.yellow(recipeName)} is not a valid recipe name.`)
+
+    const recipes = await listRecipes()
+    const recipeNames = recipes.map(({ name }) => name)
+    const {
+      bestMatch: { target: suggestion },
+    } = findBestMatch(recipeName, recipeNames)
+    const applySuggestion = await new Promise((resolve) => {
+      const prompt = inquirer.prompt({
+        type: 'confirm',
+        name: 'suggestion',
+        message: `Did you mean ${utils.chalk.blue(suggestion)}`,
+        default: false,
+      })
+
+      setTimeout(() => {
+        // @ts-ignore
+        prompt.ui.close()
+        resolve(false)
+      }, SUGGESTION_TIMEOUT)
+
+      // eslint-disable-next-line promise/catch-or-return
+      prompt.then((value) => resolve(value.suggestion))
+    })
+
+    if (applySuggestion) {
+      return recipesCommand(suggestion, options, command)
+    }
+  }
+}
+
+const runRecipe = ({ config, recipeName, repositoryRoot }) => {
+  const recipe = getRecipe(recipeName)
+
+  return recipe.run({ config, repositoryRoot })
+}
+
+/**
+ * Creates the `netlify recipes` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createRecipesCommand = (program) =>
+  program
+    .command('recipes')
+    .argument('[name]', 'name of the recipe')
+    .description(`(Beta) Create and modify files in a project using pre-defined recipes`)
+    .option('-n, --name <name>', 'recipe name to use')
+    .addExamples(['netlify recipes my-recipe', 'netlify recipes --name my-recipe'])
+    .action(recipesCommand)
+
+module.exports = { createRecipesCommand, runRecipe }

package/src/lib/api.js

@@ -1,76 +1,5 @@
-const fetch = require('node-fetch')
-
 const { warn } = require('../utils/command-helpers')
 
-const getHeaders = ({ token }) => ({
-  'Content-Type': 'application/json',
-  Authorization: `Bearer ${token}`,
-})
-
-const getErrorMessage = async ({ response }) => {
-  const contentType = response.headers.get('content-type')
-  if (contentType && contentType.includes('application/json')) {
-    const json = await response.json()
-    return json.message
-  }
-  const text = await response.text()
-  return text
-}
-
-const checkResponse = async ({ response }) => {
-  if (!response.ok) {
-    const message = await getErrorMessage({ response }).catch(() => {})
-    const errorPostfix = message ? ` and message '${message}'` : ''
-    throw new Error(`Request failed with status '${response.status}'${errorPostfix}`)
-  }
-}
-
-const getApiUrl = ({ api }) => `${api.scheme}://${api.host}${api.pathPrefix}`
-
-const apiPost = async ({ api, data, path }) => {
-  const apiUrl = getApiUrl({ api })
-  const response = await fetch(`${apiUrl}/${path}`, {
-    method: 'POST',
-    body: JSON.stringify(data),
-    headers: getHeaders({ token: api.accessToken }),
-    agent: api.agent,
-  })
-
-  await checkResponse({ response })
-
-  return response
-}
-
-const uploadEdgeHandlers = async ({ api, bundleBuffer, deployId, manifest }) => {
-  // TODO: use open-api spec via api when it is exposed
-  const response = await apiPost({ api, path: `deploys/${deployId}/edge_handlers`, data: manifest })
-  const { error, exists, upload_url: uploadUrl } = await response.json()
-  if (error) {
-    throw new Error(error)
-  }
-
-  if (exists) {
-    return false
-  }
-
-  if (!uploadUrl) {
-    throw new Error('Missing upload URL')
-  }
-
-  const putResponse = await fetch(uploadUrl, {
-    method: 'PUT',
-    body: bundleBuffer,
-    headers: {
-      'Content-Type': 'application/javascript',
-    },
-    agent: api.agent,
-  })
-
-  await checkResponse({ response: putResponse })
-
-  return true
-}
-
 const cancelDeploy = async ({ api, deployId }) => {
   try {
     await api.cancelSiteDeploy({ deploy_id: deployId })
@@ -92,4 +21,4 @@ const listSites = async ({ api, options }) => {
   return sites
 }
 
-module.exports = { uploadEdgeHandlers, cancelDeploy, listSites }
+module.exports = { cancelDeploy, listSites }

package/src/lib/edge-functions/consts.js

@@ -0,0 +1,21 @@
+const DEFAULT_SRC_DIR = 'netlify/edge-functions'
+const DIST_IMPORT_MAP_PATH = 'edge-functions-import-map.json'
+const INTERNAL_EDGE_FUNCTIONS_FOLDER = 'edge-functions'
+const EDGE_FUNCTIONS_FOLDER = 'edge-functions-dist'
+const PUBLIC_URL_PATH = '.netlify/internal/edge-functions'
+
+// 1 second
+const SERVER_POLL_INTERNAL = 1e3
+
+// 10 seconds
+const SERVER_POLL_TIMEOUT = 1e4
+
+module.exports = {
+  DEFAULT_SRC_DIR,
+  DIST_IMPORT_MAP_PATH,
+  INTERNAL_EDGE_FUNCTIONS_FOLDER,
+  EDGE_FUNCTIONS_FOLDER,
+  PUBLIC_URL_PATH,
+  SERVER_POLL_INTERNAL,
+  SERVER_POLL_TIMEOUT,
+}

package/src/lib/edge-functions/deploy.js

@@ -0,0 +1,41 @@
+// @ts-check
+const { stat } = require('fs').promises
+const path = require('path')
+
+const { getPathInProject } = require('../settings')
+
+const { EDGE_FUNCTIONS_FOLDER, PUBLIC_URL_PATH } = require('./consts')
+
+const distPath = getPathInProject([EDGE_FUNCTIONS_FOLDER])
+
+const deployFileNormalizer = (file) => {
+  const isEdgeFunction = file.root === distPath
+  const normalizedPath = isEdgeFunction ? path.join(PUBLIC_URL_PATH, file.normalizedPath) : file.normalizedPath
+
+  return {
+    ...file,
+    normalizedPath,
+  }
+}
+
+const getDistPathIfExists = async () => {
+  try {
+    const stats = await stat(distPath)
+
+    if (!stats.isDirectory()) {
+      throw new Error(`Path ${distPath} must be a directory.`)
+    }
+
+    return distPath
+  } catch {
+    // no-op
+  }
+}
+
+const isEdgeFunctionFile = (filePath) => filePath.startsWith(`${PUBLIC_URL_PATH}${path.sep}`)
+
+module.exports = {
+  deployFileNormalizer,
+  getDistPathIfExists,
+  isEdgeFunctionFile,
+}

package/src/lib/edge-functions/editor-helper.js

@@ -0,0 +1,41 @@
+const { env } = require('process')
+
+const inquirer = require('inquirer')
+
+const { runRecipe } = require('../../commands/recipes')
+
+const STATE_PROMPT_PROPERTY = 'promptVSCodeSettings'
+
+const promptEditorHelper = async ({ NETLIFYDEVLOG, chalk, config, log, repositoryRoot, state }) => {
+  const isVSCode = env.TERM_PROGRAM === 'vscode'
+  const hasShownPrompt = Boolean(state.get(STATE_PROMPT_PROPERTY))
+  const hasEdgeFunctions = Boolean(config.edge_functions && config.edge_functions.length !== 0)
+
+  if (!isVSCode || hasShownPrompt || !hasEdgeFunctions) {
+    return
+  }
+
+  state.set(STATE_PROMPT_PROPERTY, true)
+
+  const message = 'Would you like to configure VS Code to use Edge Functions?'
+  const { confirm } = await inquirer.prompt({
+    type: 'confirm',
+    name: 'confirm',
+    message,
+    default: true,
+  })
+
+  if (!confirm) {
+    log(
+      `${NETLIFYDEVLOG} You can start this configuration manually by running ${chalk.magenta.bold(
+        'netlify recipes vscode',
+      )}.`,
+    )
+
+    return
+  }
+
+  await runRecipe({ config, recipeName: 'vscode', repositoryRoot })
+}
+
+module.exports = { promptEditorHelper }

package/src/lib/edge-functions/headers.js

@@ -0,0 +1,7 @@
+module.exports = {
+  Functions: 'x-deno-functions',
+  Geo: 'x-nf-geo',
+  PassHost: 'X-NF-Pass-Host',
+  Passthrough: 'x-deno-pass',
+  RequestID: 'X-NF-Request-ID',
+}

package/src/lib/edge-functions/index.js

@@ -0,0 +1,7 @@
+// @ts-check
+const constants = require('./consts')
+const deploy = require('./deploy')
+const editorHelper = require('./editor-helper')
+const proxy = require('./proxy')
+
+module.exports = { ...constants, ...deploy, ...editorHelper, ...proxy }