netlify-cli 15.9.1-rc.0 → 15.10.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

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

@@ -1,6 +1,7 @@
 // @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'
@@ -11,13 +12,8 @@ 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 {object} config
- * @param {string} config.configPath
- * @param {string} config.siteRoot
- */
+// 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']))
 
@@ -30,9 +26,6 @@ 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]))
@@ -43,26 +36,9 @@ 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, debug, dry, offline, quiet, saveConfig },
-  projectDir,
+  options: { configPath, context, cwd = process.cwd(), debug, dry, offline, quiet, saveConfig },
 }) => ({
   cachedConfig,
   configPath,
@@ -75,35 +51,14 @@ const getBuildOptions = ({
   telemetry: false,
   buffer: false,
   offline,
-  cwd: projectDir,
+  cwd,
   quiet,
   saveConfig,
 })
 
-/**
- *
- * @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 runNetlifyBuild = async ({ cachedConfig, env, options, settings, site, timeline = 'build' }) => {
   const { default: buildSite, startDev } = await netlifyBuildPromise
   const sharedOptions = getBuildOptions({
-    projectDir,
     cachedConfig,
     options,
   })
@@ -163,19 +118,13 @@ export const runNetlifyBuild = async ({
   // 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

@@ -48,11 +48,7 @@ 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: {
-      // 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,
   })
@@ -94,7 +90,7 @@ export const runCommand = (command, env = {}, spinner = null) => {
           ? `${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 })
@@ -104,13 +100,6 @@ 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
@@ -119,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)

package/src/utils/build-info.mjs

@@ -1,19 +0,0 @@
-// @ts-check
-
-/**
- * Detects and filters the build setting for a project and a command
- * @param {import('../commands/base-command.mjs').default} command
- */
-export const detectBuildSettings = async (command) => {
-  const { project, workspacePackage } = command
-  const buildSettings = await project.getBuildSettings(project.workspace ? workspacePackage : '')
-  return buildSettings
-    .filter((setting) => {
-      if (project.workspace && project.relativeBaseDirectory && setting.packagePath) {
-        return project.relativeBaseDirectory.startsWith(setting.packagePath)
-      }
-
-      return true
-    })
-    .filter((setting) => setting.devCommand)
-}