netlify-cli 15.9.0 → 15.9.1-rc.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,64 +1,72 @@
 // @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):',
+      message: 'Base directory `(blank for current dir):',
       default: defaultBaseDir,
     },
     {
@@ -79,34 +87,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 +195,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

@@ -599,6 +599,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/run-build.mjs

@@ -1,7 +1,6 @@
 // @ts-check
 import { promises as fs } from 'fs'
 import path from 'path'
-import process from 'process'
 
 import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from '../lib/edge-functions/consts.mjs'
 import { getPathInProject } from '../lib/settings.mjs'
@@ -12,8 +11,13 @@ 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.
+/**
+ * Copies `netlify.toml`, if one is defined, into the `.netlify` internal
+ * directory and returns the path to its new location.
+ * @param {object} config
+ * @param {string} config.configPath
+ * @param {string} config.siteRoot
+ */
 const copyConfig = async ({ configPath, siteRoot }) => {
   const newConfigPath = path.resolve(siteRoot, getPathInProject(['netlify.toml']))
 
@@ -26,6 +30,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,9 +43,26 @@ const cleanInternalDirectory = async (basePath) => {
   await Promise.all(ops)
 }
 
+/**
+ *
+ * @param {object} config
+ * @param {string} config.projectDir
+ * @param {*} config.cachedConfig
+ * @param {object} config.options
+ * @param {string} config.options.configPath
+ * @param {*} config.options.context
+ * @param {string=} config.options.cwd
+ * @param {boolean} config.options.debug
+ * @param {boolean} config.options.dry
+ * @param {boolean} config.options.offline
+ * @param {boolean} config.options.quiet
+ * @param {boolean} config.options.saveConfig
+ * @returns
+ */
 const getBuildOptions = ({
   cachedConfig,
-  options: { configPath, context, cwd = process.cwd(), debug, dry, offline, quiet, saveConfig },
+  options: { configPath, context, debug, dry, offline, quiet, saveConfig },
+  projectDir,
 }) => ({
   cachedConfig,
   configPath,
@@ -51,14 +75,35 @@ const getBuildOptions = ({
   telemetry: false,
   buffer: false,
   offline,
-  cwd,
+  cwd: projectDir,
   quiet,
   saveConfig,
 })
 
-const runNetlifyBuild = async ({ cachedConfig, env, options, settings, site, timeline = 'build' }) => {
+/**
+ *
+ * @param {object} config
+ * @param {*} config.cachedConfig
+ * @param {NodeJS.ProcessEnv} config.env
+ * @param {*} config.options The flags of the command
+ * @param {string} config.projectDir
+ * @param {import('./types.js').ServerSettings} config.settings
+ * @param {*} config.site
+ * @param {'build' | 'dev'} config.timeline
+ * @returns
+ */
+export const runNetlifyBuild = async ({
+  cachedConfig,
+  env,
+  options,
+  projectDir,
+  settings,
+  site,
+  timeline = 'build',
+}) => {
   const { default: buildSite, startDev } = await netlifyBuildPromise
   const sharedOptions = getBuildOptions({
+    projectDir,
     cachedConfig,
     options,
   })
@@ -118,13 +163,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

@@ -48,7 +48,11 @@ export const runCommand = (command, env = {}, spinner = null) => {
     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,
   })
@@ -90,7 +94,7 @@ export const runCommand = (command, env = {}, spinner = null) => {
           ? `${NETLIFYDEVERR} ${result.shortMessage}`
           : `${NETLIFYDEVWARN} "${command}" exited with code ${result.exitCode}`
 
-        log(`${errorMessage}. Shutting down Netlify Dev server`)
+        log(`\n\n${errorMessage}. Shutting down Netlify Dev server`)
       }
 
       return await cleanupBeforeExit({ exitCode: 1 })
@@ -100,6 +104,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 +119,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/telemetry/report-error.mjs

@@ -25,15 +25,19 @@ export const reportError = async function (error, config = {}) {
     return
   }
 
+  // convert a NotifiableError to an error class
+  // eslint-disable-next-line unicorn/no-nested-ternary
+  const err = error instanceof Error ? error : typeof error === 'string' ? new Error(error) : error
+
   const globalConfig = await getGlobalConfig()
 
   const options = JSON.stringify({
     type: 'error',
     data: {
-      message: error.message,
-      name: error.name,
-      stack: error.stack,
-      cause: error.cause,
+      message: err.message,
+      name: err.name,
+      stack: err.stack,
+      cause: err.cause,
       severity: config.severity,
       user: {
         id: globalConfig.get('userId'),

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 {}
-}