netlify-cli 12.5.0 → 12.7.0

package/src/utils/run-build.mjs

@@ -0,0 +1,129 @@
+// @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'
+
+import { error } from './command-helpers.mjs'
+import { startFrameworkServer } from './framework-server.mjs'
+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']))
+
+  try {
+    await fs.copyFile(configPath, newConfigPath)
+  } catch {
+    // no-op
+  }
+
+  return newConfigPath
+}
+
+const cleanInternalDirectory = async (basePath) => {
+  const ops = [INTERNAL_FUNCTIONS_FOLDER, INTERNAL_EDGE_FUNCTIONS_FOLDER, 'netlify.toml'].map((name) => {
+    const fullPath = path.resolve(basePath, getPathInProject([name]))
+
+    return fs.rm(fullPath, { force: true, recursive: true })
+  })
+
+  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, options, settings, site, timeline = 'build' }) => {
+  const { default: buildSite, startDev } = await netlifyBuildPromise
+  const sharedOptions = getBuildOptions({
+    cachedConfig,
+    options,
+  })
+  const devCommand = async (settingsOverrides = {}) => {
+    const { ipVersion } = await startFrameworkServer({
+      settings: {
+        ...settings,
+        ...settingsOverrides,
+      },
+    })
+
+    settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
+  }
+
+  if (timeline === 'build') {
+    // Start by cleaning the internal directory, as it may have artifacts left
+    // by previous builds.
+    await cleanInternalDirectory(site.root)
+
+    // 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 buildSiteOptions = {
+      ...sharedOptions,
+      outputConfigPath: tempConfigPath,
+      saveConfig: true,
+    }
+
+    // Run Netlify Build using the main entry point.
+    const { success } = await buildSite(buildSiteOptions)
+
+    if (!success) {
+      error('Could not start local server due to a build error')
+
+      return {}
+    }
+
+    // Start the dev server, forcing the usage of a static server as opposed to
+    // the framework server.
+    await devCommand({
+      command: undefined,
+      useStaticServer: true,
+    })
+
+    return { configPath: tempConfigPath }
+  }
+
+  const startDevOptions = {
+    ...sharedOptions,
+
+    // Set `quiet` to suppress non-essential output from Netlify Build unless
+    // the `debug` flag is set.
+    quiet: !options.debug,
+  }
+
+  // Run Netlify Build using the `startDev` entry point.
+  const { error: startDevError, success } = await startDev(devCommand, startDevOptions)
+
+  if (!success) {
+    error(`Could not start local development server\n\n${startDevError.message}\n\n${startDevError.stack}`)
+  }
+
+  return {}
+}
+
+export const runDevTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'dev' })
+
+export const runBuildTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'build' })

package/src/utils/shell.mjs

@@ -0,0 +1,120 @@
+// @ts-check
+import process from 'process'
+
+import execa from 'execa'
+import stripAnsiCc from 'strip-ansi-control-characters'
+
+import { chalk, log, NETLIFYDEVERR, NETLIFYDEVWARN } from './command-helpers.mjs'
+import { processOnExit } from './dev.mjs'
+
+/**
+ * @type {(() => Promise<void>)[]} - array of functions to run before the process exits
+ */
+const cleanupWork = []
+
+let cleanupStarted = false
+
+/**
+ * @param {() => Promise<void>} job
+ */
+export const addCleanupJob = (job) => {
+  cleanupWork.push(job)
+}
+
+/**
+ * @param {object} input
+ * @param {number=} input.exitCode The exit code to return when exiting the process after cleanup
+ */
+const cleanupBeforeExit = async ({ exitCode }) => {
+  // If cleanup has started, then wherever started it will be responsible for exiting
+  if (!cleanupStarted) {
+    cleanupStarted = true
+    try {
+      await Promise.all(cleanupWork.map((cleanup) => cleanup()))
+    } finally {
+      process.exit(exitCode)
+    }
+  }
+}
+
+/**
+ * Run a command and pipe stdout, stderr and stdin
+ * @param {string} command
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {execa.ExecaChildProcess<string>}
+ */
+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,
+    // windowsHide needs to be false for child process to terminate properly on Windows
+    windowsHide: false,
+  })
+
+  // This ensures that an active spinner stays at the bottom of the commandline
+  // even though the actual framework command might be outputting stuff
+  const pipeDataWithSpinner = (writeStream, chunk) => {
+    if (spinner && spinner.isSpinning) {
+      spinner.clear()
+      spinner.isSilent = true
+    }
+    writeStream.write(chunk, () => {
+      if (spinner && spinner.isSpinning) {
+        spinner.isSilent = false
+        spinner.render()
+      }
+    })
+  }
+
+  commandProcess.stdout.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stdout))
+  commandProcess.stderr.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stderr))
+  process.stdin.pipe(commandProcess.stdin)
+
+  // we can't try->await->catch since we don't want to block on the framework server which
+  // is a long running process
+  // eslint-disable-next-line promise/catch-or-return
+  commandProcess
+    // eslint-disable-next-line promise/prefer-await-to-then
+    .then(async () => {
+      const result = await commandProcess
+      const [commandWithoutArgs] = command.split(' ')
+      if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
+        log(
+          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(`${errorMessage}. Shutting down Netlify Dev server`)
+      }
+
+      return await cleanupBeforeExit({ exitCode: 1 })
+    })
+  processOnExit(async () => await cleanupBeforeExit({}))
+
+  return commandProcess
+}
+
+const isNonExistingCommandError = ({ command, error: commandError }) => {
+  // `ENOENT` is only returned for non Windows systems
+  // See https://github.com/sindresorhus/execa/pull/447
+  if (commandError.code === 'ENOENT') {
+    return true
+  }
+
+  // if the command is a package manager we let it report the error
+  if (['yarn', 'npm'].includes(command)) {
+    return false
+  }
+
+  // this only works on English versions of Windows
+  return (
+    typeof commandError.message === 'string' &&
+    commandError.message.includes('is not recognized as an internal or external command')
+  )
+}

package/src/utils/state-config.mjs

@@ -6,7 +6,7 @@ import dotProp from 'dot-prop'
 import findUp from 'find-up'
 import writeFileAtomic from 'write-file-atomic'
 
-import { getPathInProject } from '../lib/settings.cjs'
+import { getPathInProject } from '../lib/settings.mjs'
 
 const STATE_PATH = getPathInProject(['state.json'])
 const permissionError = "You don't have access to this file."

package/src/utils/static-server.mjs

@@ -0,0 +1,34 @@
+// @ts-check
+import path from 'path'
+
+import fastifyStatic from '@fastify/static'
+import Fastify from 'fastify'
+
+import { log, NETLIFYDEVLOG } from './command-helpers.mjs'
+
+export const startStaticServer = async ({ settings }) => {
+  const server = Fastify()
+  const rootPath = path.resolve(settings.dist)
+  server.register(fastifyStatic, {
+    root: rootPath,
+    etag: false,
+    acceptRanges: false,
+    lastModified: false,
+  })
+
+  server.setNotFoundHandler((_req, res) => {
+    res.code(404).sendFile('404.html', rootPath)
+  })
+
+  server.addHook('onRequest', (req, reply, done) => {
+    reply.header('X-Powered-by', 'netlify-dev')
+    const validMethods = ['GET', 'HEAD']
+    if (!validMethods.includes(req.method)) {
+      reply.code(405).send('Method Not Allowed')
+    }
+    done()
+  })
+
+  await server.listen({ port: settings.frameworkPort })
+  log(`\n${NETLIFYDEVLOG} Static server listening to`, settings.frameworkPort)
+}

package/src/utils/validation.mjs

@@ -0,0 +1,15 @@
+// @ts-check
+import { BANG, chalk } from './command-helpers.mjs'
+
+export const getGeoCountryArgParser = (exampleCommand) => (arg) => {
+  // Validate that the arg passed is two letters only for country
+  // See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes
+  if (!/^[a-z]{2}$/i.test(arg)) {
+    throw new Error(
+      `The geo country code must use a two letter abbreviation.
+      ${chalk.red(BANG)}  Example:
+      ${exampleCommand}`,
+    )
+  }
+  return arg.toUpperCase()
+}