@netlify/build 28.0.0-rc → 28.0.0

package/src/core/normalize_flags.js

@@ -1,69 +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 },
-  }
-}
-
-// 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/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)
-}

package/src/error/handle.js

@@ -1,57 +0,0 @@
-import { cwd as getCwd } from 'process'
-
-import { pathExists } from 'path-exists'
-
-import { logBuildError } from '../log/messages/core.js'
-import { logOldCliVersionError } from '../log/old_version.js'
-
-import { removeErrorColors } from './colors.js'
-import { getErrorInfo } from './info.js'
-import { reportBuildError } from './monitor/report.js'
-import { parseErrorInfo } from './parse/parse.js'
-
-// Logs and reports a build failure
-export const handleBuildError = async function (
-  error,
-  { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts },
-) {
-  const basicErrorInfo = parseErrorInfo(error)
-
-  if (await isCancelCrash(error)) {
-    return basicErrorInfo
-  }
-
-  removeErrorColors(error)
-  // Some errors, such as telemetry ones, should not be logged
-  if (basicErrorInfo.showInBuildLog) {
-    logBuildError({ error, netlifyConfig, mode, logs, debug, testOpts })
-  }
-  logOldCliVersionError({ mode, testOpts })
-  await reportBuildError({ error, errorMonitor, childEnv, logs, testOpts })
-
-  return basicErrorInfo
-}
-
-// When builds are canceled, the whole filesystem is being deleted.
-// However, the process (and build) keeps going. Because no files exist anymore,
-// the build eventually crashes with a randomly odd error. Those should not be
-// logged nor reported.
-// However builds canceled with `utils.build.cancelBuild()` should still show
-// "Build canceled by ..."
-const isCancelCrash = async function (error) {
-  const [{ type }] = getErrorInfo(error)
-  if (type === 'cancelBuild') {
-    return false
-  }
-
-  try {
-    // TODO: find a better way to detect that the build is being cancelled.
-    // Otherwise bugs due to (for example) the build command removing
-    // `process.cwd` are currently not logged/reported.
-    const cwd = getCwd()
-    return !(await pathExists(cwd))
-    // `process.cwd()` fails when the current directory does not exist
-  } catch {
-    return true
-  }
-}

package/src/error/info.js

@@ -1,46 +0,0 @@
-// Add information related to an error without colliding with existing properties
-export const addDefaultErrorInfo = function (error, info) {
-  if (!canHaveErrorInfo(error)) {
-    return
-  }
-
-  error[CUSTOM_ERROR_KEY] = { ...info, ...error[CUSTOM_ERROR_KEY] }
-}
-
-// Retrieve error information added by our system
-export const addErrorInfo = function (error, info) {
-  if (!canHaveErrorInfo(error)) {
-    return
-  }
-
-  error[CUSTOM_ERROR_KEY] = { ...error[CUSTOM_ERROR_KEY], ...info }
-}
-
-export const getErrorInfo = function (error) {
-  if (!isBuildError(error)) {
-    return [{}, error]
-  }
-
-  const { [CUSTOM_ERROR_KEY]: errorInfo, ...errorA } = error
-  return [errorInfo, errorA]
-}
-
-// Change error type from one to another
-export const changeErrorType = function (error, oldType, newType) {
-  const [{ type }] = getErrorInfo(error)
-  if (type === oldType) {
-    addErrorInfo(error, { type: newType })
-  }
-}
-
-export const isBuildError = function (error) {
-  return canHaveErrorInfo(error) && error[CUSTOM_ERROR_KEY] !== undefined
-}
-
-// Exceptions that are not objects (including `Error` instances) cannot have an
-// `CUSTOM_ERROR_KEY` property
-const canHaveErrorInfo = function (error) {
-  return error != null
-}
-
-export const CUSTOM_ERROR_KEY = 'customErrorInfo'

package/src/error/monitor/location.js

@@ -1,21 +0,0 @@
-// Retrieve plugin's location and build logs
-export const getLocationMetadata = function (location, envMetadata) {
-  const buildLogs = getBuildLogs(envMetadata)
-
-  if (buildLogs === undefined && location === undefined) {
-    return
-  }
-
-  return { buildLogs, ...location }
-}
-
-// Retrieve the URL to the build logs
-const getBuildLogs = function ({ SITE_NAME, DEPLOY_ID }) {
-  if (SITE_NAME === undefined || DEPLOY_ID === undefined) {
-    return
-  }
-
-  return `${NETLIFY_ORIGIN}/sites/${SITE_NAME}/deploys/${DEPLOY_ID}`
-}
-
-const NETLIFY_ORIGIN = 'https://app.netlify.com'

package/src/error/monitor/normalize.js

@@ -1,96 +0,0 @@
-// We group errors by `error.message`. However some `error.message` contain
-// unique IDs, etc. which defeats that grouping. So we normalize those to make
-// them consistent
-export const normalizeGroupingMessage = function (message, type) {
-  const messageA = removeDependenciesLogs(message, type)
-  const messageB = NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA)
-
-  // If this is a functions bundling error, we'll use additional normalization
-  // rules to group errors more aggressively.
-  if (type === 'functionsBundling') {
-    return FUNCTIONS_BUNDLING_REGEXPS.reduce(normalizeMessage, messageB)
-  }
-
-  return messageB
-}
-
-// Discard debug/info installation information
-const removeDependenciesLogs = function (message, type) {
-  if (type !== 'dependencies') {
-    return message
-  }
-
-  return message.split('\n').filter(isErrorLine).join('\n')
-}
-
-const isErrorLine = function (line) {
-  return ERROR_LINES.some((errorLine) => line.startsWith(errorLine))
-}
-
-const ERROR_LINES = [
-  // Prefix for npm
-  'npm ERR!',
-  // Prefix for Yarn
-  'error',
-]
-
-const normalizeMessage = function (message, [regExp, replacement]) {
-  return message.replace(regExp, replacement)
-}
-
-const NORMALIZE_REGEXPS = [
-  // Base64 URL
-  [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
-  // File paths
-  [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
-  // Semantic versions
-  [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
-  [/version "[^"]+"/g, 'version "1.0.0"'],
-  // Cypress plugin prints the user's platform
-  [/^Platform: .*/gm, ''],
-  // URLs
-  [/https?:[\w.+~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
-  // Numbers, e.g. number of issues/problems
-  [/\d+/g, '0'],
-  // Hexadecimal strings
-  [/[\da-fA-F-]{6,}/g, 'hex'],
-  // On unknown inputs, we print the inputs
-  [/(does not accept any inputs but you specified: ).*/, '$1'],
-  [/(Unknown inputs for plugin).*/, '$1'],
-  [/(Plugin inputs should be one of: ).*/, '$1'],
-  // On required inputs, we print the inputs
-  [/^Plugin inputs[^]*/gm, ''],
-  [/(Required inputs for plugin).*/gm, '$1'],
-  // Netlify Functions validation check
-  [/(should target a directory, not a regular file):.*/, '$1'],
-  // zip-it-and-ship-it error when there is an `import()` but dependencies
-  // were not installed
-  [/(Cannot find module) '([^']+)'/g, "$1 'moduleName'"],
-  [/(A Netlify Function is using) "[^"]+"/g, '$1 "moduleName"'],
-  // Deploy upload errors include the filename
-  [/(Upload cancelled).*/g, '$1'],
-  [/(aborting upload of file).*/g, '$1'],
-  // netlify-plugin-inline-critical-css errors prints a list of file paths
-  [/Searched in: .*/g, ''],
-  // netlify-plugin-subfont prints font name in errors
-  [/(is not supported yet): .*/, '$1'],
-  // netlify-plugin-subfont prints generic information in every error that
-  // is highly build-specific
-  [/^(vers?ions|Plugin configuration|Subfont called with): {[^}]+}/gm, ''],
-  [/^Resolved entry points: \[[^\]]+]/gm, ''],
-  // netlify-plugin-minify-html parse error
-  [/(Parse Error):[^]*/, '$1'],
-  // Multiple empty lines
-  [/^\s*$/gm, ''],
-]
-
-const FUNCTIONS_BUNDLING_REGEXPS = [
-  // String literals and identifiers
-  [/"([^"]+)"/g, '""'],
-  [/'([^']+)'/g, "''"],
-  [/`([^`]+)`/g, '``'],
-
-  // Rust crates
-  [/(?:Downloaded \S+ v[\d.]+\s*)+/gm, 'Downloaded crates'],
-  [/(?:Compiling \S+ v[\d.]+\s*)+/gm, 'Compiled crates'],
-]

package/src/error/monitor/print.js

@@ -1,42 +0,0 @@
-import { log } from '../../log/logger.js'
-
-// Print event payload instead of sending actual request during tests
-export const printEventForTest = function (
-  { name: errorClass, message: errorMessage },
-  {
-    context,
-    groupingHash,
-    severity,
-    unhandled,
-    _metadata: {
-      location,
-      plugin: { packageName, homepage } = {},
-      pluginPackageJson,
-      tsConfig,
-      env: { BUILD_ID } = {},
-      other,
-    },
-  },
-  logs,
-) {
-  const eventString = JSON.stringify(
-    {
-      errorClass,
-      errorMessage,
-      context,
-      groupingHash,
-      severity,
-      unhandled,
-      location,
-      packageName,
-      pluginPackageJson: pluginPackageJson !== undefined,
-      homepage,
-      tsConfig,
-      BUILD_ID,
-      other,
-    },
-    null,
-    2,
-  )
-  log(logs, `\nError monitoring payload:\n${eventString}`)
-}