@netlify/build 27.18.4 → 27.18.6-rc

package/src/core/lingering.js

@@ -1,85 +0,0 @@
-import psList from 'ps-list'
-
-import { logLingeringProcesses } from '../log/messages/core.js'
-
-// Print a warning when some build processes are still running.
-// We cannot rely on using the process tree:
-//  - This is because it is impossible to know whether a process was a child of
-//    of another once its parent process has exited. When that happens, the s
-//    child becomes inherited by `init`, changing its `ppid`. The information
-//    about the original parent is then lost.
-//  - The only way to implement this would be to repeatedly list processes as
-//    the build command is ongoing. However, this would fail to detect processes
-//    spawned just before the build commands ends.
-// We cannot list processes before and after the build command and use the
-// difference.
-//  - This is because other processes (unrelated to @netlify/build) might be
-//    running at the same time. This includes OS background processes.
-// Therefore, we run this in a controlled environment only (the buildbot) and
-// exclude specific processes manually. This is a lesser evil, although still
-// quite hacky.
-export const warnOnLingeringProcesses = async function ({
-  mode,
-  logs,
-  testOpts: { silentLingeringProcesses = false },
-}) {
-  if (mode !== 'buildbot' || silentLingeringProcesses) {
-    return
-  }
-
-  const processes = await psList()
-
-  const commands = processes.map(getCommand).filter(isNotIgnoredCommand)
-
-  if (commands.length === 0) {
-    return
-  }
-
-  logLingeringProcesses(logs, commands)
-}
-
-// `cmd` is only available on Unix. Unlike `name`, it includes the arguments.
-const getCommand = function ({ name, cmd = name }) {
-  return cmd
-}
-
-// We ignore any command known to be internal to the buildbot.
-// We also ignore commands known not to complete properly in builds if they are
-// widely used.
-const isNotIgnoredCommand = function (command) {
-  return !IGNORED_COMMANDS.some((ignoredCommand) => matchesIgnoredCommand(command, ignoredCommand))
-}
-
-const matchesIgnoredCommand = function (command, ignoredCommand) {
-  if (typeof ignoredCommand === 'string') {
-    return command.includes(ignoredCommand)
-  }
-
-  return ignoredCommand.test(command)
-}
-
-const IGNORED_COMMANDS = [
-  // TODO: Those can most likely be removed
-  'ps',
-  'grep',
-  'bash',
-
-  // Internal buildbot commands
-  '[build]',
-  /buildbot.*\[node]/,
-  // buildbot's main Bash script
-  '/opt/build-bin/build',
-  // `@netlify/build` binary itself
-  'netlify-build',
-  // Plugin child processes spawned by @netlify/build
-  '@netlify/build',
-  // Shown for parent processes with currently running child processes.
-  // Happens on `ps` itself.
-  'defunct',
-
-  // Processes often left running. We should report those but don't because of
-  // how common those are in production builds
-  'gatsby-telemetry',
-  'jest-worker',
-  'broccoli-babel-transpiler',
-]

package/src/core/main.js

@@ -1,165 +0,0 @@
-import { handleBuildError } from '../error/handle.js'
-import { logTimer, logBuildSuccess } from '../log/messages/core.js'
-import { trackBuildComplete } from '../telemetry/main.js'
-import { reportTimers } from '../time/report.js'
-
-import { execBuild, startBuild } from './build.js'
-import { getSeverity } from './severity.js'
-
-export { startDev } from './dev.js'
-export { runCoreSteps } from '../steps/run_core_steps.js'
-
-/**
- * Main entry point of Netlify Build.
- * Runs a builds and returns whether it succeeded or not.
- *
- * @param  {object} [flags] - build configuration CLI flags
- * @param  {string} [flags.config] - Path to the configuration file
- * @param  {string} [flags.cwd] - Current directory. Used to retrieve the configuration file
- * @param  {string} [flags.repositoryRoot] - Git repository root directory. Used to retrieve the configuration file.
- * @param  {string} [flags.apiHost] - Netlify API endpoint
- * @param  {string} [flags.token] - Netlify API token for authentication
- * @param  {string} [flags.siteId] - Netlify Site ID
- * @param  {string} [flags.deployId] - Netlify Deploy ID
- * @param  {string} [flags.context] - Build context
- * @param  {string} [flags.branch] - Repository branch
- * @param  {boolean} [flags.dry=false] - Run in dry mode, i.e. printing steps without executing them
- * @param  {string} [flags.nodePath] - Path to the Node.js binary to use in the build command and plugins
- * @param  {boolean} [flags.buffer=false] - Buffer output instead of printing it
- *
- * @returns {object} buildResult
- * @returns {boolean} buildResult.success - Whether build succeeded or failed
- * @returns {number} buildResult.severityCode - Build success/failure status among:
- * 0 (success), 1 (build cancelled), 2 (user error), 3 (plugin error), 4 (system error). Can be used as exit code.
- * @returns {string[]} buildResult.logs - When using the `buffer` option, all log messages
- */
-export default async function buildSite(flags = {}) {
-  const {
-    errorMonitor,
-    framework,
-    mode,
-    logs,
-    debug,
-    systemLogFile,
-    testOpts,
-    statsdOpts,
-    dry,
-    telemetry,
-    buildId,
-    deployId,
-    ...flagsA
-  } = startBuild(flags)
-  const errorParams = { errorMonitor, mode, logs, debug, testOpts }
-
-  try {
-    const {
-      pluginsOptions,
-      netlifyConfig: netlifyConfigA,
-      siteInfo,
-      userNodeVersion,
-      stepsCount,
-      timers,
-      durationNs,
-      configMutations,
-    } = await execBuild({
-      ...flagsA,
-      buildId,
-      systemLogFile,
-      deployId,
-      dry,
-      errorMonitor,
-      mode,
-      logs,
-      debug,
-      testOpts,
-      errorParams,
-    })
-    await handleBuildSuccess({
-      framework,
-      dry,
-      logs,
-      timers,
-      durationNs,
-      statsdOpts,
-    })
-    const { success, severityCode, status } = getSeverity('success')
-    await telemetryReport({
-      buildId,
-      deployId,
-      status,
-      stepsCount,
-      pluginsOptions,
-      durationNs,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-      errorParams,
-    })
-    return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations }
-  } catch (error) {
-    const { severity } = await handleBuildError(error, errorParams)
-    const { pluginsOptions, siteInfo, userNodeVersion } = errorParams
-    const { success, severityCode, status } = getSeverity(severity)
-    await telemetryReport({
-      buildId,
-      deployId,
-      status,
-      pluginsOptions,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-      errorParams,
-    })
-    return { success, severityCode, logs }
-  }
-}
-
-// Logs and reports that a build successfully ended
-const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts }) {
-  if (dry) {
-    return
-  }
-
-  logBuildSuccess(logs)
-
-  logTimer(logs, durationNs, 'Netlify Build')
-  await reportTimers({ timers, statsdOpts, framework })
-}
-
-// Handles the calls and errors of telemetry reports
-const telemetryReport = async function ({
-  deployId,
-  buildId,
-  status,
-  stepsCount,
-  pluginsOptions,
-  durationNs,
-  siteInfo,
-  telemetry,
-  userNodeVersion,
-  framework,
-  testOpts,
-  errorParams,
-}) {
-  try {
-    await trackBuildComplete({
-      deployId,
-      buildId,
-      status,
-      stepsCount,
-      pluginsOptions,
-      durationNs,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-    })
-  } catch (error) {
-    await handleBuildError(error, errorParams)
-  }
-}

package/src/core/missing_side_file.js

@@ -1,29 +0,0 @@
-import { relative } from 'path'
-
-import { pathExists } from 'path-exists'
-
-import { logMissingSideFile } from '../log/messages/core.js'
-
-// Some files like `_headers` and `_redirects` must be copied to the publish
-// directory to be used in production. When those are present in the repository
-// but not in the publish directory, this most likely indicates that the build
-// command accidentally forgot to copy those. We then print a warning message.
-export const warnOnMissingSideFiles = async function ({
-  buildDir,
-  netlifyConfig: {
-    build: { publish },
-  },
-  logs,
-}) {
-  await Promise.all(SIDE_FILES.map((sideFile) => warnOnMissingSideFile({ logs, sideFile, buildDir, publish })))
-}
-
-const SIDE_FILES = ['_headers', '_redirects']
-
-const warnOnMissingSideFile = async function ({ logs, sideFile, buildDir, publish }) {
-  if (!(await pathExists(`${buildDir}/${sideFile}`)) || (await pathExists(`${publish}/${sideFile}`))) {
-    return
-  }
-
-  logMissingSideFile(logs, sideFile, relative(buildDir, publish))
-}

package/src/core/normalize_flags.js

@@ -1,70 +0,0 @@
-import { env, execPath } from 'process'
-
-import { logFlags } from '../log/messages/config.js'
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js'
-
-// Normalize CLI flags
-export const normalizeFlags = function (flags, logs) {
-  const rawFlags = removeFalsy(flags)
-
-  // Combine the flags object env with the process.env
-  const combinedEnv = { ...env, ...rawFlags.env }
-  const defaultFlags = getDefaultFlags(rawFlags, combinedEnv)
-
-  // The telemetry flag requires specific logic to compute
-  const telemetryFlag = computeTelemetry(rawFlags, combinedEnv)
-
-  const mergedFlags = {
-    ...defaultFlags,
-    ...rawFlags,
-    ...telemetryFlag,
-    statsdOpts: { ...defaultFlags.statsd, ...rawFlags.statsd },
-    featureFlags: { ...defaultFlags.featureFlags, ...rawFlags.featureFlags },
-  }
-  const normalizedFlags = removeFalsy(mergedFlags)
-
-  logFlags(logs, rawFlags, normalizedFlags)
-
-  return normalizedFlags
-}
-
-// Default values of CLI flags
-const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
-  return {
-    env: envOpt,
-    nodePath: execPath,
-    token: combinedEnv.NETLIFY_AUTH_TOKEN,
-    mode: REQUIRE_MODE,
-    offline: false,
-    telemetry: false,
-    verbose: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
-    functionsDistDir: DEFAULT_FUNCTIONS_DIST,
-    edgeFunctionsDistDir: DEFAULT_EDGE_FUNCTIONS_DIST,
-    cacheDir: DEFAULT_CACHE_DIR,
-    deployId: combinedEnv.DEPLOY_ID,
-    buildId: combinedEnv.BUILD_ID,
-    debug: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
-    bugsnagKey: combinedEnv.BUGSNAG_KEY,
-    sendStatus: false,
-    saveConfig: false,
-    apiHost: 'api.netlify.com',
-    testOpts: {},
-    featureFlags: DEFAULT_FEATURE_FLAGS,
-    statsd: { port: DEFAULT_STATSD_PORT },
-    timeline: 'build',
-  }
-}
-
-// Compute the telemetry flag, it's disabled by default and we want to always disable it
-// if BUILD_TELEMETRY_DISABLED is passed.
-const computeTelemetry = function (flags, envOpts) {
-  return envOpts.BUILD_TELEMETRY_DISABLED ? { telemetry: false } : { telemetry: flags.telemetry }
-}
-
-const REQUIRE_MODE = 'require'
-const DEFAULT_EDGE_FUNCTIONS_DIST = '.netlify/edge-functions-dist/'
-const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/'
-const DEFAULT_CACHE_DIR = '.netlify/cache/'
-const DEFAULT_STATSD_PORT = 8125

package/src/core/severity.js

@@ -1,22 +0,0 @@
-// Used to extract exit codes and respective status strings
-// 1|2|3 indicate whether this was a user|plugin|system error.
-export const getSeverity = function (severity = FALLBACK_SEVERITY) {
-  const severityEntry = severity in SEVERITY_MAP ? SEVERITY_MAP[severity] : FALLBACK_SEVERITY_ENTRY
-  const success = severity === SUCCESS_SEVERITY
-  return { success, ...severityEntry }
-}
-
-// Map error severities to exit codes and status (used for telemetry purposes)
-/* eslint-disable no-magic-numbers */
-const SEVERITY_MAP = {
-  success: { severityCode: 0, status: 'success' },
-  none: { severityCode: 1, status: 'cancelled' },
-  info: { severityCode: 2, status: 'user-error' },
-  warning: { severityCode: 3, status: 'plugin-error' },
-  error: { severityCode: 4, status: 'system-error' },
-}
-/* eslint-enable no-magic-numbers */
-const SUCCESS_SEVERITY = 'success'
-// Indicates a bug in our codebase
-const FALLBACK_SEVERITY = 'error'
-export const FALLBACK_SEVERITY_ENTRY = SEVERITY_MAP[FALLBACK_SEVERITY]

package/src/core/user_node_version.js

@@ -1,41 +0,0 @@
-import { version as currentVersion, execPath } from 'process'
-
-import { execa } from 'execa'
-import semver from 'semver'
-
-import { addErrorInfo } from '../error/info.js'
-
-// Retrieve Node.js version if the Node.js path is using nvm.
-// `node.exe` on Windows, `bin/node` on Unix.
-const NVM_NODE_VERSION_REGEXP = /[/\\]v(\d+\.\d+\.\d+)[/\\](bin[/\\]node|node.exe)$/
-
-// Retrieve Node.js version from current process
-const getCurrentNodeVersion = function () {
-  return semver.clean(currentVersion)
-}
-
-// Retrieve Node.js version from `--node-path` or fallback to extracting the current Node.js process version
-export const getUserNodeVersion = async function (nodePath) {
-  // No `--node-path` CLI flag, use the current node process version
-  if (nodePath === execPath) {
-    return getCurrentNodeVersion()
-  }
-
-  // Extract version from path
-  const result = NVM_NODE_VERSION_REGEXP.exec(nodePath)
-  if (result !== null) {
-    return result[1]
-  }
-
-  // Fallback to actually running `node --version` with the given nodePath
-  const { stdout } = await execa(nodePath, ['--version'], { reject: false })
-  const version = semver.clean(stdout)
-
-  if (version === null) {
-    const error = new Error(`Invalid --node-path CLI flag: ${nodePath}`)
-    addErrorInfo(error, { type: 'resolveConfig' })
-    throw error
-  }
-
-  return version
-}

package/src/env/changes.js

@@ -1,52 +0,0 @@
-import { env } from 'process'
-
-import filterObj from 'filter-obj'
-import mapObj from 'map-obj'
-
-// If plugins modify `process.env`, this is propagated in other plugins and in
-// `build.command`. Since those are different processes, we figure out when they
-// do this and communicate the new `process.env` to other processes.
-export const getNewEnvChanges = function (envBefore, netlifyConfig, netlifyConfigCopy) {
-  const processEnvChanges = diffEnv(envBefore, env)
-  const netlifyConfigEnvChanges = diffEnv(netlifyConfig.build.environment, netlifyConfigCopy.build.environment)
-  return { ...processEnvChanges, ...netlifyConfigEnvChanges }
-}
-
-const diffEnv = function (envBefore, envAfter) {
-  const envChanges = filterObj(envAfter, (name, value) => value !== envBefore[name])
-  const deletedEnv = filterObj(envBefore, (name) => envAfter[name] === undefined)
-  const deletedEnvA = mapObj(deletedEnv, setToNull)
-  return { ...envChanges, ...deletedEnvA }
-}
-
-// `undefined` is not JSON-serializable (which is used in process IPC), so we
-// convert it to `null`
-// Note: `process.env[name] = undefined` actually does
-// `process.env[name] = 'undefined'` in Node.js.
-const setToNull = function (name) {
-  return [name, null]
-}
-
-// Set `process.env` changes from a previous different plugin.
-// Can also merge with a `currentEnv` plain object instead of `process.env`.
-export const setEnvChanges = function (envChanges, currentEnv = env) {
-  Object.entries(envChanges).forEach(([name, value]) => {
-    setEnvChange(name, value, currentEnv)
-  })
-  return { ...currentEnv }
-}
-
-const setEnvChange = function (name, value, currentEnv) {
-  if (currentEnv[name] === value) {
-    return
-  }
-
-  if (value === null) {
-    // `currentEnv` is a mutable variable
-    // eslint-disable-next-line fp/no-delete
-    delete currentEnv[name]
-    return
-  }
-
-  currentEnv[name] = value
-}

package/src/env/main.js

@@ -1,19 +0,0 @@
-import { env } from 'process'
-
-import filterObj from 'filter-obj'
-
-import { getParentColorEnv } from '../log/colors.js'
-
-// Retrieve the environment variables passed to plugins and `build.command`
-// When run locally, this tries to emulate the production environment.
-export const getChildEnv = function ({ envOpt, env: allConfigEnv }) {
-  const parentColorEnv = getParentColorEnv()
-  const parentEnv = { ...env, ...allConfigEnv, ...envOpt, ...parentColorEnv }
-  return filterObj(parentEnv, shouldKeepEnv)
-}
-
-const shouldKeepEnv = function (key) {
-  return !REMOVED_PARENT_ENV.has(key.toLowerCase())
-}
-
-const REMOVED_PARENT_ENV = new Set(['bugsnag_key'])

package/src/env/metadata.js

@@ -1,81 +0,0 @@
-import { env } from 'process'
-
-import filterObj from 'filter-obj'
-
-// Retrieve enviroment variables used in error monitoring
-export const getEnvMetadata = function (childEnv = env) {
-  return filterObj(childEnv, isEnvMetadata)
-}
-
-const isEnvMetadata = function (name) {
-  return ENVIRONMENT_VARIABLES.has(name)
-}
-
-// This is sorted by most useful in debugging to least
-const ENVIRONMENT_VARIABLES = new Set([
-  // URL and IDs
-  'BUILD_ID',
-  'DEPLOY_ID',
-  'SITE_NAME',
-  'SITE_ID',
-  'REPOSITORY_URL',
-  'URL',
-  'DEPLOY_URL',
-  'DEPLOY_PRIME_URL',
-
-  // Git
-  'HEAD',
-  'COMMIT_REF',
-  'CACHED_COMMIT_REF',
-  'BRANCH',
-  'CONTEXT',
-  'PULL_REQUEST',
-  'REVIEW_ID',
-
-  // Node
-  'NODE_VERSION',
-  'AWS_LAMBDA_JS_RUNTIME',
-  'NPM_VERSION',
-  'YARN_VERSION',
-  'NPM_FLAGS',
-  'YARN_FLAGS',
-  'NVM_FLAGS',
-  'NODE_ENV',
-
-  // Go
-  'GO_VERSION',
-  'GO_IMPORT_PATH',
-  'GOCACHE',
-  'GOPATH',
-  'GOROOT',
-
-  // Ruby
-  'RUBY_VERSION',
-  'GEM_HOME',
-  'GEM_PATH',
-  'GIMME_GCO_ENABLED',
-  'GIMME_ENV_PREFIX',
-  'GIMME_GO_PREFIX',
-  'GIMME_NO_ENV_ALIAS',
-  'GIMME_TYPE',
-  'IRBRC',
-  'MY_RUBY_HOME',
-
-  // Hugo
-  'HUGO_VERSION',
-
-  // Java
-  'JAVA_VERSION',
-
-  // PHP
-  'PHP_VERSION',
-
-  // Python
-  'PIPENV_DEFAULT_PYTHON_VERSION',
-  'PIPENV_RUNTIME',
-  'PIPENV_VENV_IN_PROJECT',
-
-  // Git LFS
-  'GIT_LFS_ENABLED',
-  'GIT_LFS_FETCH_INCLUDE',
-])

package/src/error/api.js

@@ -1,46 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { addErrorInfo } from './info.js'
-
-// Wrap `api.*` methods so that they add more error information
-export const addApiErrorHandlers = function (api) {
-  if (api === undefined) {
-    return
-  }
-
-  return mapObj(api, addErrorHandler)
-}
-
-const addErrorHandler = function (key, value) {
-  if (typeof value !== 'function') {
-    return [key, value]
-  }
-
-  const valueA = apiMethodHandler.bind(null, key, value)
-  return [key, valueA]
-}
-
-const apiMethodHandler = async function (endpoint, method, parameters, ...args) {
-  try {
-    return await method(parameters, ...args)
-  } catch (error) {
-    redactError(error)
-    addErrorInfo(error, { type: 'api', location: { endpoint, parameters } })
-    throw error
-  }
-}
-
-// Redact API token from the build logs
-const redactError = function (error) {
-  if (
-    error instanceof Error &&
-    isPlainObj(error.data) &&
-    isPlainObj(error.data.headers) &&
-    typeof error.data.headers.Authorization === 'string'
-  ) {
-    error.data.headers.Authorization = error.data.headers.Authorization.replace(HEX_REGEXP, 'HEX')
-  }
-}
-
-const HEX_REGEXP = /[\da-f]{6,}/g

package/src/error/build.js

@@ -1,50 +0,0 @@
-import safeJsonStringify from 'safe-json-stringify'
-
-import { CUSTOM_ERROR_KEY } from './info.js'
-
-// Retrieve error information from child process and re-build it in current
-// process. We need this since errors static properties are not kept by
-// `v8.serialize()`.
-export const jsonToError = function ({ name, message, stack, ...errorProps }) {
-  // eslint-disable-next-line unicorn/error-message
-  const error = new Error('')
-
-  assignErrorProps(error, { name, message, stack })
-  // Assign static error properties (if any)
-  // We need to mutate the `error` directly to preserve its `name`, `stack`, etc.
-  // eslint-disable-next-line fp/no-mutating-assign
-  Object.assign(error, errorProps)
-
-  return error
-}
-
-// Make sure `name`, `message` and `stack` are not enumerable
-const assignErrorProps = function (error, values) {
-  ERROR_PROPS.forEach((name) => {
-    assignErrorProp(error, name, values[name])
-  })
-}
-
-const ERROR_PROPS = ['name', 'message', 'stack']
-
-const assignErrorProp = function (error, name, value) {
-  // `Object.defineProperty()` requires direct mutation
-  // eslint-disable-next-line fp/no-mutating-methods
-  Object.defineProperty(error, name, { value, enumerable: false, writable: true, configurable: true })
-}
-
-// Inverse of `jsonToError()`.
-export const errorToJson = function (error) {
-  const { name, message, stack, [CUSTOM_ERROR_KEY]: customError, ...errorProps } = error
-
-  // diagnosticText is not enumerable in TSError so we need to grab it manually. destructuring won't work.
-  if (error.diagnosticText) {
-    // eslint-disable-next-line fp/no-mutation
-    errorProps.diagnosticText = error.diagnosticText
-  }
-
-  return {
-    ...safeJsonStringify.ensureProperties(errorProps),
-    ...safeJsonStringify.ensureProperties({ name, message, stack, [CUSTOM_ERROR_KEY]: customError }),
-  }
-}

package/src/error/cancel.js

@@ -1,8 +0,0 @@
-// Cancel builds, for example when a plugin uses `utils.build.cancelBuild()`
-export const cancelBuild = async function ({ api, deployId }) {
-  if (api === undefined || !deployId) {
-    return
-  }
-
-  await api.cancelSiteDeploy({ deploy_id: deployId })
-}

package/src/error/colors.js

@@ -1,11 +0,0 @@
-import stripAnsi from 'strip-ansi'
-
-// Remove ANSI sequences from `error.message`
-export const removeErrorColors = function (error) {
-  if (!(error instanceof Error)) {
-    return
-  }
-
-  error.message = stripAnsi(error.message)
-  error.stack = stripAnsi(error.stack)
-}