netlify-cli 15.11.0 → 16.0.0

package/src/utils/init/config-manual.mjs

@@ -5,7 +5,12 @@ import { exit, log } from '../command-helpers.mjs'
 
 import { createDeployKey, getBuildSettings, saveNetlifyToml, setupSite } from './utils.mjs'
 
-const addDeployKey = async ({ deployKey }) => {
+/**
+ * Prompts for granting the netlify ssh public key access to your repo
+ * @param {object} deployKey
+ * @param {string} deployKey.public_key
+ */
+const addDeployKey = async (deployKey) => {
   log('\nGive this Netlify SSH public key access to your repository:\n')
   log(`\n${deployKey.public_key}\n\n`)
 
@@ -23,6 +28,11 @@ const addDeployKey = async ({ deployKey }) => {
   }
 }
 
+/**
+ * @param {object} config
+ * @param {Awaited<ReturnType<import('../../utils/get-repo-data.mjs').default>>} config.repoData
+ * @returns {Promise<string>}
+ */
 const getRepoPath = async ({ repoData }) => {
   const { repoPath } = await inquirer.prompt([
     {
@@ -30,6 +40,9 @@ const getRepoPath = async ({ repoData }) => {
       name: 'repoPath',
       message: 'The SSH URL of the remote git repo:',
       default: repoData.url,
+      /**
+       * @param {string} url
+       */
       validate: (url) => SSH_URL_REGEXP.test(url) || 'The URL provided does not use the SSH protocol',
     },
   ])
@@ -37,7 +50,11 @@ const getRepoPath = async ({ repoData }) => {
   return repoPath
 }
 
-const addDeployHook = async ({ deployHook }) => {
+/**
+ * @param {string} deployHook
+ * @returns
+ */
+const addDeployHook = async (deployHook) => {
   log('\nConfigure the following webhook for your repository:\n')
   log(`\n${deployHook}\n\n`)
   const { deployHookAdded } = await inquirer.prompt([
@@ -55,14 +72,14 @@ const addDeployHook = async ({ deployHook }) => {
 /**
  * @param {object} config
  * @param {import('../../commands/base-command.mjs').default} config.command
- * @param {*} config.repoData
+ * @param {Awaited<ReturnType<import('../../utils/get-repo-data.mjs').default>>} config.repoData
  * @param {string} config.siteId
  */
 export default async function configManual({ command, repoData, siteId }) {
   const { netlify } = command
   const {
     api,
-    cachedConfig: { configPath, env },
+    cachedConfig: { configPath },
     config,
     repositoryRoot,
     site: { root: siteRoot },
@@ -72,12 +89,12 @@ export default async function configManual({ command, repoData, siteId }) {
     repositoryRoot,
     siteRoot,
     config,
-    env,
+    command,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
 
   const deployKey = await createDeployKey({ api })
-  await addDeployKey({ deployKey })
+  await addDeployKey(deployKey)
 
   const repoPath = await getRepoPath({ repoData })
   const repo = {
@@ -99,7 +116,7 @@ export default async function configManual({ command, repoData, siteId }) {
     configPlugins: config.plugins,
     pluginsToInstall,
   })
-  const deployHookAdded = await addDeployHook({ deployHook: updatedSite.deploy_hook })
+  const deployHookAdded = await addDeployHook(updatedSite.deploy_hook)
   if (!deployHookAdded) {
     exit()
   }

package/src/utils/init/utils.mjs

@@ -1,66 +1,75 @@
 // @ts-check
 import { writeFile } from 'fs/promises'
 import path from 'path'
-import process from 'process'
 
 import cleanDeep from 'clean-deep'
 import inquirer from 'inquirer'
 
 import { fileExistsAsync } from '../../lib/fs.mjs'
 import { normalizeBackslash } from '../../lib/path.mjs'
+import { detectBuildSettings } from '../build-info.mjs'
 import { chalk, error as failAndExit, log, warn } from '../command-helpers.mjs'
 
-import { getFrameworkInfo } from './frameworks.mjs'
-import { detectNodeVersion } from './node-version.mjs'
 import { getRecommendPlugins, getUIPlugins } from './plugins.mjs'
 
-const normalizeDir = ({ baseDirectory, defaultValue, dir }) => {
-  if (dir === undefined) {
-    return defaultValue
-  }
-
-  const relativeDir = path.relative(baseDirectory, dir)
-  return relativeDir || defaultValue
-}
-
-const getDefaultBase = ({ baseDirectory, repositoryRoot }) => {
-  if (baseDirectory !== repositoryRoot && baseDirectory.startsWith(repositoryRoot)) {
-    return path.relative(repositoryRoot, baseDirectory)
-  }
-}
+// these plugins represent runtimes that are
+// expected to be "automatically" installed. Even though
+// they can be installed on package/toml, we always
+// want them installed in the site settings. When installed
+// there our build will automatically install the latest without
+// user management of the versioning.
+const pluginsToAlwaysInstall = new Set(['@netlify/plugin-nextjs'])
+
+/**
+ * Retrieve a list of plugins to auto install
+ * @param {string[]=} pluginsInstalled
+ * @param {string[]=} pluginsRecommended
+ * @returns
+ */
+export const getPluginsToAutoInstall = (pluginsInstalled = [], pluginsRecommended = []) =>
+  pluginsRecommended.reduce(
+    (acc, plugin) =>
+      pluginsInstalled.includes(plugin) && !pluginsToAlwaysInstall.has(plugin) ? acc : [...acc, plugin],
+
+    /** @type {string[]} */ ([]),
+  )
 
-const getDefaultSettings = ({
-  baseDirectory,
-  config,
-  frameworkBuildCommand,
-  frameworkBuildDir,
-  frameworkPlugins,
-  repositoryRoot,
-}) => {
-  const recommendedPlugins = getRecommendPlugins(frameworkPlugins, config)
-  const {
-    command: defaultBuildCmd = frameworkBuildCommand,
-    functions: defaultFunctionsDir,
-    publish: defaultBuildDir = frameworkBuildDir,
-  } = config.build
+/**
+ *
+ * @param {Partial<import('@netlify/build-info').Settings>} settings
+ * @param {*} config
+ * @param {import('../../commands/base-command.mjs').default} command
+ */
+const normalizeSettings = (settings, config, command) => {
+  const plugins = getPluginsToAutoInstall(settings.plugins_from_config_file, settings.plugins_recommended)
+  const recommendedPlugins = getRecommendPlugins(plugins, config)
 
   return {
-    defaultBaseDir: getDefaultBase({ repositoryRoot, baseDirectory }),
-    defaultBuildCmd,
-    defaultBuildDir: normalizeDir({ baseDirectory, dir: defaultBuildDir, defaultValue: '.' }),
-    defaultFunctionsDir: normalizeDir({ baseDirectory, dir: defaultFunctionsDir, defaultValue: 'netlify/functions' }),
+    defaultBaseDir: settings.baseDirectory ?? command.project.relativeBaseDirectory ?? '',
+    defaultBuildCmd: config.build.command || settings.buildCommand,
+    defaultBuildDir: settings.dist,
+    defaultFunctionsDir: config.build.functions || 'netlify/functions',
     recommendedPlugins,
   }
 }
 
+/**
+ *
+ * @param {object} param0
+ * @param {string} param0.defaultBaseDir
+ * @param {string} param0.defaultBuildCmd
+ * @param {string=} param0.defaultBuildDir
+ * @returns
+ */
 const getPromptInputs = ({ defaultBaseDir, defaultBuildCmd, defaultBuildDir }) => {
   const inputs = [
-    defaultBaseDir !== undefined && {
-      type: 'input',
-      name: 'baseDir',
-      message: 'Base directory (e.g. projects/frontend):',
-      default: defaultBaseDir,
-    },
+    defaultBaseDir !== undefined &&
+      defaultBaseDir !== '' && {
+        type: 'input',
+        name: 'baseDir',
+        message: 'Base directory `(blank for current dir):',
+        default: defaultBaseDir,
+      },
     {
       type: 'input',
       name: 'buildCmd',
@@ -79,34 +88,22 @@ const getPromptInputs = ({ defaultBaseDir, defaultBuildCmd, defaultBuildDir }) =
   return inputs.filter(Boolean)
 }
 
-// `repositoryRoot === siteRoot` means the base directory wasn't detected by @netlify/config, so we use cwd()
-const getBaseDirectory = ({ repositoryRoot, siteRoot }) =>
-  path.normalize(repositoryRoot) === path.normalize(siteRoot) ? process.cwd() : siteRoot
-
-export const getBuildSettings = async ({ config, env, repositoryRoot, siteRoot }) => {
-  const baseDirectory = getBaseDirectory({ repositoryRoot, siteRoot })
-  const nodeVersion = await detectNodeVersion({ baseDirectory, env })
-  const {
-    frameworkBuildCommand,
-    frameworkBuildDir,
-    frameworkName,
-    frameworkPlugins = [],
-  } = await getFrameworkInfo({
-    baseDirectory,
-    nodeVersion,
-  })
+/**
+ * @param {object} param0
+ * @param {*} param0.config
+ * @param {import('../../commands/base-command.mjs').default} param0.command
+ */
+export const getBuildSettings = async ({ command, config }) => {
+  const settings = await detectBuildSettings(command)
+  // TODO: add prompt for asking to choose the build command
+  /** @type {Partial<import('@netlify/build-info').Settings>} */
+  // eslint-disable-next-line unicorn/explicit-length-check
+  const setting = settings.length > 0 ? settings[0] : {}
   const { defaultBaseDir, defaultBuildCmd, defaultBuildDir, defaultFunctionsDir, recommendedPlugins } =
-    await getDefaultSettings({
-      repositoryRoot,
-      config,
-      baseDirectory,
-      frameworkBuildCommand,
-      frameworkBuildDir,
-      frameworkPlugins,
-    })
-
-  if (recommendedPlugins.length !== 0) {
-    log(`Configuring ${formatTitle(frameworkName)} runtime...`)
+    await normalizeSettings(setting, config, command)
+
+  if (recommendedPlugins.length !== 0 && setting.framework?.name) {
+    log(`Configuring ${formatTitle(setting.framework?.name)} runtime...`)
     log()
   }
 
@@ -199,6 +196,9 @@ export const formatErrorMessage = ({ error, message }) => {
   return `${message} with error: ${chalk.red(errorMessage)}`
 }
 
+/**
+ * @param {string} title
+ */
 const formatTitle = (title) => chalk.cyan(title)
 
 export const createDeployKey = async ({ api }) => {

package/src/utils/proxy-server.mjs

@@ -36,19 +36,21 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
 /**
  *
  * @param {object} params
+ * @param {string=} params.accountId
  * @param {*} params.addonsUrls
- * @param {import('../commands/base-command.mjs').NetlifyOptions["config"]} params.config
+ * @param {import('../commands/types.js').NetlifyOptions["config"]} params.config
  * @param {string} [params.configPath] An override for the Netlify config path
  * @param {boolean} params.debug
- * @param {import('../commands/base-command.mjs').NetlifyOptions["cachedConfig"]['env']} params.env
+ * @param {import('../commands/types.js').NetlifyOptions["cachedConfig"]['env']} params.env
  * @param {InspectSettings} params.inspectSettings
  * @param {() => Promise<object>} params.getUpdatedConfig
  * @param {string} params.geolocationMode
  * @param {string} params.geoCountry
  * @param {*} params.settings
  * @param {boolean} params.offline
- * @param {*} params.site
+ * @param {object} params.site
  * @param {*} params.siteInfo
+ * @param {string} params.projectDir
  * @param {import('./state-config.mjs').default} params.state
  * @returns
  */
@@ -64,6 +66,7 @@ export const startProxyServer = async ({
   getUpdatedConfig,
   inspectSettings,
   offline,
+  projectDir,
   settings,
   site,
   siteInfo,
@@ -80,7 +83,7 @@ export const startProxyServer = async ({
     getUpdatedConfig,
     inspectSettings,
     offline,
-    projectDir: site.root,
+    projectDir,
     settings,
     state,
     siteInfo,

package/src/utils/proxy.mjs

@@ -375,7 +375,6 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
   proxy.before('web', 'stream', (req) => {
     // See https://github.com/http-party/node-http-proxy/issues/1219#issuecomment-511110375
     if (req.headers.expect) {
-      // eslint-disable-next-line no-underscore-dangle
       req.__expectHeader = req.headers.expect
       delete req.headers.expect
     }
@@ -402,9 +401,7 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
       handleProxyRequest(req, proxyReq)
     }
 
-    // eslint-disable-next-line no-underscore-dangle
     if (req.__expectHeader) {
-      // eslint-disable-next-line no-underscore-dangle
       proxyReq.setHeader('Expect', req.__expectHeader)
     }
     if (req.originalBody) {
@@ -599,6 +596,10 @@ const onRequest = async (
   proxy.web(req, res, options)
 }
 
+/**
+ * @param {import('./types.js').ServerSettings} settings
+ * @returns
+ */
 export const getProxyUrl = function (settings) {
   const scheme = settings.https ? 'https' : 'http'
   return `${scheme}://localhost:${settings.port}`

package/src/utils/read-repo-url.mjs

@@ -7,6 +7,7 @@ import fetch from 'node-fetch'
 const GITHUB = 'GitHub'
 
 /**
+ * @param {string} _url
  * Takes a url like https://github.com/netlify-labs/all-the-functions/tree/master/functions/9-using-middleware
  * and returns https://api.github.com/repos/netlify-labs/all-the-functions/contents/functions/9-using-middleware
  */
@@ -36,6 +37,9 @@ const getRepoURLContents = async function (repoHost, ownerAndRepo, contentsPath)
   throw new Error('unsupported host ', repoHost)
 }
 
+/**
+ * @param {string} _url
+ */
 export const validateRepoURL = function (_url) {
   // TODO: use `url.URL()` instead
   // eslint-disable-next-line n/no-deprecated-api

package/src/utils/run-build.mjs

@@ -1,7 +1,6 @@
 // @ts-check
 import { promises as fs } from 'fs'
-import path from 'path'
-import process from 'process'
+import path, { join } from 'path'
 
 import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from '../lib/edge-functions/consts.mjs'
 import { getPathInProject } from '../lib/settings.mjs'
@@ -12,10 +11,14 @@ import { INTERNAL_FUNCTIONS_FOLDER } from './functions/index.mjs'
 
 const netlifyBuildPromise = import('@netlify/build')
 
-// Copies `netlify.toml`, if one is defined, into the `.netlify` internal
-// directory and returns the path to its new location.
-const copyConfig = async ({ configPath, siteRoot }) => {
-  const newConfigPath = path.resolve(siteRoot, getPathInProject(['netlify.toml']))
+/**
+ * Copies `netlify.toml`, if one is defined, into the `.netlify` internal
+ * directory and returns the path to its new location.
+ * @param {string} configPath
+ * @param {string} destinationFolder The folder where it should be copied to. Either the root of the repo or a package inside a monorepo
+ */
+const copyConfig = async (configPath, destinationFolder) => {
+  const newConfigPath = path.resolve(destinationFolder, getPathInProject(['netlify.toml']))
 
   try {
     await fs.copyFile(configPath, newConfigPath)
@@ -26,6 +29,9 @@ const copyConfig = async ({ configPath, siteRoot }) => {
   return newConfigPath
 }
 
+/**
+ * @param {string} basePath
+ */
 const cleanInternalDirectory = async (basePath) => {
   const ops = [INTERNAL_FUNCTIONS_FOLDER, INTERNAL_EDGE_FUNCTIONS_FOLDER, 'netlify.toml'].map((name) => {
     const fullPath = path.resolve(basePath, getPathInProject([name]))
@@ -36,38 +42,52 @@ const cleanInternalDirectory = async (basePath) => {
   await Promise.all(ops)
 }
 
-const getBuildOptions = ({
-  cachedConfig,
-  options: { configPath, context, cwd = process.cwd(), debug, dry, offline, quiet, saveConfig },
-}) => ({
-  cachedConfig,
-  configPath,
-  siteId: cachedConfig.siteInfo.id,
-  token: cachedConfig.token,
-  dry,
-  debug,
-  context,
-  mode: 'cli',
-  telemetry: false,
-  buffer: false,
-  offline,
-  cwd,
-  quiet,
-  saveConfig,
-})
-
-const runNetlifyBuild = async ({ cachedConfig, env, options, settings, site, timeline = 'build' }) => {
+/**
+ * @param {object} params
+ * @param {import('../commands/base-command.mjs').default} params.command
+ * @param {import('../commands/base-command.mjs').default} params.command
+ * @param {*} params.options The flags of the command
+ * @param {import('./types.js').ServerSettings} params.settings
+ * @param {NodeJS.ProcessEnv} [params.env]
+ * @param {'build' | 'dev'} [params.timeline]
+ * @returns
+ */
+export const runNetlifyBuild = async ({ command, env = {}, options, settings, timeline = 'build' }) => {
+  const { cachedConfig, site } = command.netlify
+
   const { default: buildSite, startDev } = await netlifyBuildPromise
-  const sharedOptions = getBuildOptions({
+
+  const sharedOptions = {
     cachedConfig,
-    options,
-  })
+    configPath: cachedConfig.configPath,
+    siteId: cachedConfig.siteInfo.id,
+    token: cachedConfig.token,
+    dry: options.dry,
+    debug: options.debug,
+    context: options.context,
+    mode: 'cli',
+    telemetry: false,
+    buffer: false,
+    offline: options.offline,
+    packagePath: command.workspacePackage,
+    cwd: cachedConfig.buildDir,
+    quiet: options.quiet,
+    saveConfig: options.saveConfig,
+  }
+
   const devCommand = async (settingsOverrides = {}) => {
+    let cwd = command.workingDir
+
+    if (command.project.workspace?.packages.length) {
+      cwd = join(command.project.jsWorkspaceRoot, settings.baseDirectory || '')
+    }
+
     const { ipVersion } = await startFrameworkServer({
       settings: {
         ...settings,
         ...settingsOverrides,
       },
+      cwd,
     })
 
     settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
@@ -80,7 +100,7 @@ const runNetlifyBuild = async ({ cachedConfig, env, options, settings, site, tim
 
     // Copy `netlify.toml` into the internal directory. This will be the new
     // location of the config file for the duration of the command.
-    const tempConfigPath = await copyConfig({ configPath: cachedConfig.configPath, siteRoot: site.root })
+    const tempConfigPath = await copyConfig(cachedConfig.configPath, command.workingDir)
     const buildSiteOptions = {
       ...sharedOptions,
       outputConfigPath: tempConfigPath,
@@ -118,13 +138,19 @@ const runNetlifyBuild = async ({ cachedConfig, env, options, settings, site, tim
   // Run Netlify Build using the `startDev` entry point.
   const { error: startDevError, success } = await startDev(devCommand, startDevOptions)
 
-  if (!success) {
+  if (!success && startDevError) {
     error(`Could not start local development server\n\n${startDevError.message}\n\n${startDevError.stack}`)
   }
 
   return {}
 }
 
+/**
+ * @param {Omit<Parameters<typeof runNetlifyBuild>[0], 'timeline'>} options
+ */
 export const runDevTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'dev' })
 
+/**
+ * @param {Omit<Parameters<typeof runNetlifyBuild>[0], 'timeline'>} options
+ */
 export const runBuildTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'build' })

package/src/utils/shell.mjs

@@ -40,17 +40,26 @@ const cleanupBeforeExit = async ({ exitCode }) => {
 /**
  * Run a command and pipe stdout, stderr and stdin
  * @param {string} command
- * @param {NodeJS.ProcessEnv} env
+ * @param {object} options
+ * @param {import('ora').Ora|null} [options.spinner]
+ * @param {NodeJS.ProcessEnv} [options.env]
+ * @param {string} [options.cwd]
  * @returns {execa.ExecaChildProcess<string>}
  */
-export const runCommand = (command, env = {}, spinner = null) => {
+export const runCommand = (command, options = {}) => {
+  const { cwd, env = {}, spinner = null } = options
   const commandProcess = execa.command(command, {
     preferLocal: true,
     // we use reject=false to avoid rejecting synchronously when the command doesn't exist
     reject: false,
-    env,
+    env: {
+      // we want always colorful terminal outputs
+      FORCE_COLOR: 'true',
+      ...env,
+    },
     // windowsHide needs to be false for child process to terminate properly on Windows
     windowsHide: false,
+    cwd,
   })
 
   // This ensures that an active spinner stays at the bottom of the commandline
@@ -82,8 +91,9 @@ export const runCommand = (command, env = {}, spinner = null) => {
       const [commandWithoutArgs] = command.split(' ')
       if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
         log(
-          NETLIFYDEVERR,
-          `Failed running command: ${command}. Please verify ${chalk.magenta(`'${commandWithoutArgs}'`)} exists`,
+          `${NETLIFYDEVERR} Failed running command: ${command}. Please verify ${chalk.magenta(
+            `'${commandWithoutArgs}'`,
+          )} exists`,
         )
       } else {
         const errorMessage = result.failed
@@ -100,6 +110,13 @@ export const runCommand = (command, env = {}, spinner = null) => {
   return commandProcess
 }
 
+/**
+ *
+ * @param {object} config
+ * @param {string} config.command
+ * @param {*} config.error
+ * @returns
+ */
 const isNonExistingCommandError = ({ command, error: commandError }) => {
   // `ENOENT` is only returned for non Windows systems
   // See https://github.com/sindresorhus/execa/pull/447
@@ -108,7 +125,7 @@ const isNonExistingCommandError = ({ command, error: commandError }) => {
   }
 
   // if the command is a package manager we let it report the error
-  if (['yarn', 'npm'].includes(command)) {
+  if (['yarn', 'npm', 'pnpm'].includes(command)) {
     return false
   }
 

package/src/utils/state-config.mjs

@@ -11,7 +11,11 @@ import { getPathInProject } from '../lib/settings.mjs'
 const STATE_PATH = getPathInProject(['state.json'])
 const permissionError = "You don't have access to this file."
 
-// Finds location of `.netlify/state.json`
+/**
+ * Finds location of `.netlify/state.json`
+ * @param {string} cwd
+ * @returns {string}
+ */
 const findStatePath = (cwd) => {
   const statePath = findUpSync([STATE_PATH], { cwd })
 

package/src/utils/static-server.mjs

@@ -6,6 +6,10 @@ import Fastify from 'fastify'
 
 import { log, NETLIFYDEVLOG } from './command-helpers.mjs'
 
+/**
+ * @param {object} config
+ * @param {import('./types.js').ServerSettings} config.settings
+ */
 export const startStaticServer = async ({ settings }) => {
   const server = Fastify()
   const rootPath = path.resolve(settings.dist)

package/src/utils/init/frameworks.mjs

@@ -1,23 +0,0 @@
-// @ts-check
-import { listFrameworks } from '@netlify/framework-info'
-
-export const getFrameworkInfo = async ({ baseDirectory, nodeVersion }) => {
-  const frameworks = await listFrameworks({ projectDir: baseDirectory, nodeVersion })
-  // several frameworks can be detected - first one has highest priority
-  if (frameworks.length !== 0) {
-    const [
-      {
-        build: { commands, directory },
-        name,
-        plugins,
-      },
-    ] = frameworks
-    return {
-      frameworkName: name,
-      frameworkBuildCommand: commands[0],
-      frameworkBuildDir: directory,
-      frameworkPlugins: plugins,
-    }
-  }
-  return {}
-}