netlify-cli 15.10.0-rc.1 → 15.11.0

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

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

package/src/utils/init/frameworks.mjs

@@ -0,0 +1,23 @@
+// @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 {}
+}

package/src/utils/init/utils.mjs

@@ -1,72 +1,64 @@
 // @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'
 
-// 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 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)
+  }
+}
 
-/**
- *
- * @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)
+const getDefaultSettings = ({
+  baseDirectory,
+  config,
+  frameworkBuildCommand,
+  frameworkBuildDir,
+  frameworkPlugins,
+  repositoryRoot,
+}) => {
+  const recommendedPlugins = getRecommendPlugins(frameworkPlugins, config)
+  const {
+    command: defaultBuildCmd = frameworkBuildCommand,
+    functions: defaultFunctionsDir,
+    publish: defaultBuildDir = frameworkBuildDir,
+  } = config.build
 
   return {
-    defaultBaseDir: settings.baseDirectory ?? command.project.relativeBaseDirectory ?? '',
-    defaultBuildCmd: config.build.command || settings.buildCommand,
-    defaultBuildDir: settings.dist,
-    defaultFunctionsDir: config.build.functions || 'netlify/functions',
+    defaultBaseDir: getDefaultBase({ repositoryRoot, baseDirectory }),
+    defaultBuildCmd,
+    defaultBuildDir: normalizeDir({ baseDirectory, dir: defaultBuildDir, defaultValue: '.' }),
+    defaultFunctionsDir: normalizeDir({ baseDirectory, dir: defaultFunctionsDir, defaultValue: '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 `(blank for current dir):',
+      message: 'Base directory (e.g. projects/frontend):',
       default: defaultBaseDir,
     },
     {
@@ -87,22 +79,34 @@ const getPromptInputs = ({ defaultBaseDir, defaultBuildCmd, defaultBuildDir }) =
   return inputs.filter(Boolean)
 }
 
-/**
- * @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] : {}
+// `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,
+  })
   const { defaultBaseDir, defaultBuildCmd, defaultBuildDir, defaultFunctionsDir, recommendedPlugins } =
-    await normalizeSettings(setting, config, command)
-
-  if (recommendedPlugins.length !== 0 && setting.framework?.name) {
-    log(`Configuring ${formatTitle(setting.framework?.name)} runtime...`)
+    await getDefaultSettings({
+      repositoryRoot,
+      config,
+      baseDirectory,
+      frameworkBuildCommand,
+      frameworkBuildDir,
+      frameworkPlugins,
+    })
+
+  if (recommendedPlugins.length !== 0) {
+    log(`Configuring ${formatTitle(frameworkName)} runtime...`)
     log()
   }
 
@@ -195,9 +199,6 @@ 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,21 +36,19 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
 /**
  *
  * @param {object} params
- * @param {string=} params.accountId
  * @param {*} params.addonsUrls
- * @param {import('../commands/types.js').NetlifyOptions["config"]} params.config
+ * @param {import('../commands/base-command.mjs').NetlifyOptions["config"]} params.config
  * @param {string} [params.configPath] An override for the Netlify config path
  * @param {boolean} params.debug
- * @param {import('../commands/types.js').NetlifyOptions["cachedConfig"]['env']} params.env
+ * @param {import('../commands/base-command.mjs').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 {object} params.site
+ * @param {*} params.site
  * @param {*} params.siteInfo
- * @param {string} params.projectDir
  * @param {import('./state-config.mjs').default} params.state
  * @returns
  */
@@ -66,7 +64,6 @@ export const startProxyServer = async ({
   getUpdatedConfig,
   inspectSettings,
   offline,
-  projectDir,
   settings,
   site,
   siteInfo,
@@ -83,7 +80,7 @@ export const startProxyServer = async ({
     getUpdatedConfig,
     inspectSettings,
     offline,
-    projectDir,
+    projectDir: site.root,
     settings,
     state,
     siteInfo,

package/src/utils/proxy.mjs

@@ -375,6 +375,7 @@ 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
     }
@@ -401,7 +402,9 @@ 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) {
@@ -596,10 +599,6 @@ 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,7 +7,6 @@ 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
  */
@@ -37,9 +36,6 @@ 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,6 +1,7 @@
 // @ts-check
 import { promises as fs } from 'fs'
-import path, { join } from 'path'
+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'
@@ -11,14 +12,10 @@ 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.
- * @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']))
+// 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']))
 
   try {
     await fs.copyFile(configPath, newConfigPath)
@@ -29,9 +26,6 @@ const copyConfig = async (configPath, destinationFolder) => {
   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]))
@@ -42,52 +36,38 @@ const cleanInternalDirectory = async (basePath) => {
   await Promise.all(ops)
 }
 
-/**
- * @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 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' }) => {
   const { default: buildSite, startDev } = await netlifyBuildPromise
-
-  const sharedOptions = {
+  const sharedOptions = getBuildOptions({
     cachedConfig,
-    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,
-    cwd: cachedConfig.buildDir,
-    quiet: options.quiet,
-    saveConfig: options.saveConfig,
-  }
-
+    options,
+  })
   const devCommand = async (settingsOverrides = {}) => {
-    let cwd = command.workingDir
-
-    if (command.project.workspace?.packages.length) {
-      console.log('packages', settings.baseDirectory)
-      cwd = join(command.project.jsWorkspaceRoot, settings.baseDirectory || '')
-    }
-
     const { ipVersion } = await startFrameworkServer({
       settings: {
         ...settings,
         ...settingsOverrides,
       },
-      cwd,
     })
 
     settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
@@ -100,7 +80,7 @@ export const runNetlifyBuild = async ({ command, env = {}, options, settings, ti
 
     // 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(cachedConfig.configPath, command.workingDir)
+    const tempConfigPath = await copyConfig({ configPath: cachedConfig.configPath, siteRoot: site.root })
     const buildSiteOptions = {
       ...sharedOptions,
       outputConfigPath: tempConfigPath,
@@ -138,19 +118,13 @@ export const runNetlifyBuild = async ({ command, env = {}, options, settings, ti
   // Run Netlify Build using the `startDev` entry point.
   const { error: startDevError, success } = await startDev(devCommand, startDevOptions)
 
-  if (!success && startDevError) {
+  if (!success) {
     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,26 +40,17 @@ const cleanupBeforeExit = async ({ exitCode }) => {
 /**
  * Run a command and pipe stdout, stderr and stdin
  * @param {string} command
- * @param {object} options
- * @param {import('ora').Ora|null} [options.spinner]
- * @param {NodeJS.ProcessEnv} [options.env]
- * @param {string} [options.cwd]
+ * @param {NodeJS.ProcessEnv} env
  * @returns {execa.ExecaChildProcess<string>}
  */
-export const runCommand = (command, options = {}) => {
-  const { cwd, env = {}, spinner = null } = options
+export const runCommand = (command, env = {}, spinner = null) => {
   const commandProcess = execa.command(command, {
     preferLocal: true,
     // we use reject=false to avoid rejecting synchronously when the command doesn't exist
     reject: false,
-    env: {
-      // we want always colorful terminal outputs
-      FORCE_COLOR: 'true',
-      ...env,
-    },
+    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
@@ -91,16 +82,15 @@ export const runCommand = (command, options = {}) => {
       const [commandWithoutArgs] = command.split(' ')
       if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
         log(
-          `\n\n${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
           ? `${NETLIFYDEVERR} ${result.shortMessage}`
           : `${NETLIFYDEVWARN} "${command}" exited with code ${result.exitCode}`
 
-        log(`\n\n${errorMessage}. Shutting down Netlify Dev server`)
+        log(`${errorMessage}. Shutting down Netlify Dev server`)
       }
 
       return await cleanupBeforeExit({ exitCode: 1 })
@@ -110,13 +100,6 @@ export const runCommand = (command, options = {}) => {
   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
@@ -125,7 +108,7 @@ const isNonExistingCommandError = ({ command, error: commandError }) => {
   }
 
   // if the command is a package manager we let it report the error
-  if (['yarn', 'npm', 'pnpm'].includes(command)) {
+  if (['yarn', 'npm'].includes(command)) {
     return false
   }
 

package/src/utils/state-config.mjs

@@ -11,11 +11,7 @@ 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`
- * @param {string} cwd
- * @returns {string}
- */
+// Finds location of `.netlify/state.json`
 const findStatePath = (cwd) => {
   const statePath = findUpSync([STATE_PATH], { cwd })
 

package/src/utils/static-server.mjs

@@ -6,10 +6,6 @@ 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)