@netlify/build 27.18.4 → 27.18.5-rc

package/src/install/missing.js

@@ -1,67 +0,0 @@
-import { promises as fs } from 'fs'
-import { normalize } from 'path'
-
-import { pathExists } from 'path-exists'
-import { isFile } from 'path-type'
-
-import { logInstallMissingPlugins } from '../log/messages/install.js'
-
-import { addExactDependencies } from './main.js'
-
-// Automatically install plugins if not already installed.
-// Since this is done under the hood, we always use `npm` with specific `npm`
-// options. We do not allow configure the package manager nor its options.
-// Users requiring `yarn` or custom npm/yarn flags should install the plugin in
-// their `package.json`.
-export const installMissingPlugins = async function ({ missingPlugins, autoPluginsDir, mode, logs }) {
-  const packages = missingPlugins.map(getPackage)
-  logInstallMissingPlugins(logs, packages)
-
-  await createAutoPluginsDir(logs, autoPluginsDir)
-  await addExactDependencies({ packageRoot: autoPluginsDir, isLocal: mode !== 'buildbot', packages })
-}
-
-// We pin the version without using semver ranges ^ nor ~
-const getPackage = function ({ packageName, expectedVersion }) {
-  return `${packageName}@${expectedVersion}`
-}
-
-const createAutoPluginsDir = async function (logs, autoPluginsDir) {
-  await ensureDir(logs, autoPluginsDir)
-  await createPackageJson(autoPluginsDir)
-}
-
-// Create the directory if it does not exist
-const ensureDir = async function (logs, autoPluginsDir) {
-  if (await pathExists(autoPluginsDir)) {
-    return
-  }
-
-  // If `.netlify` exists but is not a directory, we remove it first
-  const autoPluginsParent = normalize(`${autoPluginsDir}/..`)
-  if (await isFile(autoPluginsParent)) {
-    await fs.unlink(autoPluginsParent)
-  }
-
-  await fs.mkdir(autoPluginsDir, { recursive: true })
-}
-
-// Create a dummy `package.json` so we can run `npm install` and get a lock file
-const createPackageJson = async function (autoPluginsDir) {
-  const packageJsonPath = `${autoPluginsDir}/package.json`
-  if (await pathExists(packageJsonPath)) {
-    return
-  }
-
-  const packageJsonContent = JSON.stringify(AUTO_PLUGINS_PACKAGE_JSON, null, 2)
-  await fs.writeFile(packageJsonPath, packageJsonContent)
-}
-
-const AUTO_PLUGINS_PACKAGE_JSON = {
-  name: 'netlify-local-plugins',
-  description: 'This directory contains Build plugins that have been automatically installed by Netlify.',
-  version: '1.0.0',
-  private: true,
-  author: 'Netlify',
-  license: 'MIT',
-}

package/src/log/colors.js

@@ -1,34 +0,0 @@
-import { inspect } from 'util'
-
-import supportsColor from 'supports-color'
-
-// Plugin child processes use `stdio: 'pipe'` so they are always
-// non-interactive even if the parent is an interactive TTY. This means they
-// would normally lose colors. If the parent has colors, we pass an environment
-// variable to the child process to force colors.
-export const getParentColorEnv = function () {
-  if (!hasColors()) {
-    return {}
-  }
-
-  return { FORCE_COLOR: '1' }
-}
-
-// Child processes and the buildbot relies on `FORCE_COLOR=1` to set colors.
-// However `utils.inspect()` (used by `console.log()`) uses
-// `process.stdout.hasColors` which is always `undefined` when the TTY is
-// non-interactive. So we need to set `util.inspect.defaultOptions.colors`
-// manually both in plugin processes.
-export const setInspectColors = function () {
-  if (!hasColors()) {
-    return
-  }
-
-  // `inspect.defaultOptions` requires direct mutation
-  // eslint-disable-next-line fp/no-mutation
-  inspect.defaultOptions.colors = true
-}
-
-const hasColors = function () {
-  return supportsColor.stdout !== false
-}

package/src/log/description.js

@@ -1,26 +0,0 @@
-export const getBuildCommandDescription = function (buildCommandOrigin) {
-  return BUILD_COMMAND_DESCRIPTIONS[buildCommandOrigin]
-}
-
-const BUILD_COMMAND_DESCRIPTIONS = {
-  ui: 'Build command from Netlify app',
-  config: 'build.command from netlify.toml',
-  inline: 'build.command from a plugin',
-}
-
-// Retrieve human-friendly plugin origin
-export const getPluginOrigin = function (loadedFrom, origin) {
-  const originName = PLUGIN_ORIGINS[origin]
-
-  if (loadedFrom === 'package.json') {
-    return `from ${originName} and package.json`
-  }
-
-  return `from ${originName}`
-}
-
-const PLUGIN_ORIGINS = {
-  core: 'core',
-  ui: 'Netlify app',
-  config: 'netlify.toml',
-}

package/src/log/header.js

@@ -1,16 +0,0 @@
-import stringWidth from 'string-width'
-
-// Print a rectangular header
-export const getHeader = function (message) {
-  const messageWidth = stringWidth(message)
-  const headerWidth = Math.max(HEADER_MIN_WIDTH, messageWidth)
-  const line = '─'.repeat(headerWidth + PADDING_WIDTH * 2)
-  const paddingLeft = ' '.repeat(PADDING_WIDTH)
-  const paddingRight = ' '.repeat(PADDING_WIDTH + headerWidth - messageWidth)
-  return `${line}
-${paddingLeft}${message}${paddingRight}
-${line}`
-}
-
-const HEADER_MIN_WIDTH = 60
-const PADDING_WIDTH = 2

package/src/log/header_func.js

@@ -1,17 +0,0 @@
-import { parseErrorInfo } from '../error/parse/parse.js'
-
-import { logHeader, logErrorHeader } from './logger.js'
-
-// Retrieve successful or error header depending on whether `error` exists
-export const getLogHeaderFunc = function (error) {
-  if (error === undefined) {
-    return logHeader
-  }
-
-  const { severity } = parseErrorInfo(error)
-  if (severity === 'none') {
-    return logHeader
-  }
-
-  return logErrorHeader
-}

package/src/log/logger.js

@@ -1,161 +0,0 @@
-import { createWriteStream } from 'fs'
-
-import figures from 'figures'
-import indentString from 'indent-string'
-
-import { getHeader } from './header.js'
-import { serializeObject, serializeArray } from './serialize.js'
-import { THEME } from './theme.js'
-
-// When the `buffer` option is true, we return logs instead of printing them
-// on the console. The logs are accumulated in a `logs` array variable.
-export const getBufferLogs = function ({ buffer = false }) {
-  if (!buffer) {
-    return
-  }
-
-  return { stdout: [], stderr: [] }
-}
-
-// Core logging utility, used by the other methods.
-// This should be used instead of `console.log()` as it allows us to instrument
-// how any build logs is being printed.
-export const log = function (logs, string, { indent = false, color } = {}) {
-  const stringA = indent ? indentString(string, INDENT_SIZE) : string
-  const stringB = String(stringA).replace(EMPTY_LINES_REGEXP, EMPTY_LINE)
-  const stringC = color === undefined ? stringB : color(stringB)
-
-  if (logs !== undefined) {
-    // `logs` is a stateful variable
-    // eslint-disable-next-line fp/no-mutating-methods
-    logs.stdout.push(stringC)
-    return
-  }
-
-  console.log(stringC)
-}
-
-const INDENT_SIZE = 2
-
-// We need to add a zero width space character in empty lines. Otherwise the
-// buildbot removes those due to a bug: https://github.com/netlify/buildbot/issues/595
-const EMPTY_LINES_REGEXP = /^\s*$/gm
-const EMPTY_LINE = '\u{200B}'
-
-const serializeIndentedArray = function (array) {
-  return serializeArray(array.map(serializeIndentedItem))
-}
-
-const serializeIndentedItem = function (item) {
-  return indentString(item, INDENT_SIZE + 1).trimStart()
-}
-
-export const logError = function (logs, string, opts) {
-  log(logs, string, { color: THEME.errorLine, ...opts })
-}
-
-export const logWarning = function (logs, string, opts) {
-  log(logs, string, { color: THEME.warningLine, ...opts })
-}
-
-// Print a message that is under a header/subheader, i.e. indented
-export const logMessage = function (logs, string, opts) {
-  log(logs, string, { indent: true, ...opts })
-}
-
-// Print an object
-export const logObject = function (logs, object, opts) {
-  logMessage(logs, serializeObject(object), opts)
-}
-
-// Print an array
-export const logArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.none, ...opts })
-}
-
-// Print an array of errors
-export const logErrorArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.errorLine, ...opts })
-}
-
-// Print an array of warnings
-export const logWarningArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.warningLine, ...opts })
-}
-
-// Print a main section header
-export const logHeader = function (logs, string, opts) {
-  log(logs, `\n${getHeader(string)}`, { color: THEME.header, ...opts })
-}
-
-// Print a main section header, when an error happened
-export const logErrorHeader = function (logs, string, opts) {
-  logHeader(logs, string, { color: THEME.errorHeader, ...opts })
-}
-
-// Print a sub-section header
-export const logSubHeader = function (logs, string, opts) {
-  log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts })
-}
-
-// Print a sub-section header, when an error happened
-export const logErrorSubHeader = function (logs, string, opts) {
-  logSubHeader(logs, string, { color: THEME.errorSubHeader, ...opts })
-}
-
-// Print a sub-section header, when a warning happened
-export const logWarningSubHeader = function (logs, string, opts) {
-  logSubHeader(logs, string, { color: THEME.warningSubHeader, ...opts })
-}
-
-// Combines an array of elements into a single string, separated by a space,
-// and with basic serialization of non-string types
-const reduceLogLines = function (lines) {
-  return lines
-    .map((input) => {
-      if (input instanceof Error) {
-        return `${input.message} ${input.stack}`
-      }
-
-      if (typeof input === 'object') {
-        try {
-          return JSON.stringify(input)
-        } catch {
-          // Value could not be serialized to JSON, so we return the string
-          // representation.
-          return String(input)
-        }
-      }
-
-      return String(input)
-    })
-    .join(' ')
-}
-
-// Builds a function for logging data to the system logger (i.e. hidden from
-// the user-facing build logs)
-export const getSystemLogger = function (logs, debug, systemLogFile) {
-  // If the `debug` flag is used, we return a function that pipes system logs
-  // to the regular logger, as the intention is for them to end up in stdout.
-  if (debug) {
-    return (...args) => log(logs, reduceLogLines(args))
-  }
-
-  // If there's not a file descriptor configured for system logs and `debug`
-  // is not set, we return a no-op function that will swallow the errors.
-  if (!systemLogFile) {
-    return () => {
-      // no-op
-    }
-  }
-
-  // Return a function that writes to the file descriptor configured for system
-  // logs.
-  const fileDescriptor = createWriteStream(null, { fd: systemLogFile })
-
-  fileDescriptor.on('error', () => {
-    logError(logs, 'Could not write to system log file')
-  })
-
-  return (...args) => fileDescriptor.write(`${reduceLogLines(args)}\n`)
-}

package/src/log/messages/compatibility.js

@@ -1,178 +0,0 @@
-import semver from 'semver'
-
-import { isRuntime } from '../../utils/runtime.js'
-import { isPreviousMajor } from '../../utils/semver.js'
-import { getPluginOrigin } from '../description.js'
-import { logArray, logSubHeader, logWarningArray, logWarningSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logRuntime = (logs, pluginOptions) => {
-  const runtimes = pluginOptions.filter(isRuntime)
-
-  // Once we have more runtimes, this hardcoded check should be removed
-  if (runtimes.length !== 0) {
-    const [nextRuntime] = runtimes
-
-    logSubHeader(logs, `Using Next.js Runtime - v${nextRuntime.pluginPackageJson.version}`)
-  }
-}
-
-export const logLoadingPlugins = function (logs, pluginsOptions, debug) {
-  const loadingPlugins = pluginsOptions
-    .filter(isNotCorePlugin)
-    // We don't want to show runtimes as plugins
-    .filter((plugin) => !isRuntime(plugin))
-    .map((pluginOptions) => getPluginDescription(pluginOptions, debug))
-
-  if (loadingPlugins.length === 0) {
-    return
-  }
-
-  logSubHeader(logs, 'Loading plugins')
-  logArray(logs, loadingPlugins)
-}
-
-// We only logs plugins explicitly enabled by users
-const isNotCorePlugin = function ({ origin }) {
-  return origin !== 'core'
-}
-
-const getPluginDescription = function (
-  {
-    packageName,
-    pluginPackageJson: { version },
-    loadedFrom,
-    origin,
-    pinnedVersion,
-    latestVersion,
-    expectedVersion,
-    compatibleVersion,
-  },
-  debug,
-) {
-  const versionedPackage = getVersionedPackage(packageName, version)
-  const pluginOrigin = getPluginOrigin(loadedFrom, origin)
-  const description = `${THEME.highlightWords(packageName)}${versionedPackage} ${pluginOrigin}`
-  if (!debug) {
-    return description
-  }
-
-  const versions = Object.entries({
-    pinned: pinnedVersion,
-    latest: latestVersion,
-    expected: expectedVersion,
-    compatible: compatibleVersion,
-  })
-    .filter(hasVersion)
-    .map(getVersionField)
-
-  if (versions.length === 0) {
-    return description
-  }
-
-  return `${description} (${versions.join(', ')})`
-}
-
-const hasVersion = function ([, version]) {
-  return version !== undefined
-}
-
-const getVersionField = function ([versionFieldName, version]) {
-  return `${versionFieldName} ${version}`
-}
-
-// Print a warning message when old versions plugins are used.
-// This can only happen when they are installed to `package.json`.
-export const logOutdatedPlugins = function (logs, pluginsOptions) {
-  const outdatedPlugins = pluginsOptions.filter(hasOutdatedVersion).map(getOutdatedPlugin)
-
-  if (outdatedPlugins.length === 0) {
-    return
-  }
-
-  logWarningSubHeader(logs, 'Outdated plugins')
-  logWarningArray(logs, outdatedPlugins)
-}
-
-const hasOutdatedVersion = function ({ pluginPackageJson: { version }, latestVersion }) {
-  return version !== undefined && latestVersion !== undefined && semver.lt(version, latestVersion)
-}
-
-const getOutdatedPlugin = function ({
-  packageName,
-  pluginPackageJson: { version },
-  latestVersion,
-  migrationGuide,
-  loadedFrom,
-  origin,
-}) {
-  const versionedPackage = getVersionedPackage(packageName, version)
-  const outdatedDescription = getOutdatedDescription({ latestVersion, migrationGuide, loadedFrom, origin })
-  return `${THEME.warningHighlightWords(packageName)}${versionedPackage}: ${outdatedDescription}`
-}
-
-const getOutdatedDescription = function ({ latestVersion, migrationGuide, loadedFrom, origin }) {
-  const upgradeInstruction = getUpgradeInstruction(loadedFrom, origin)
-  if (migrationGuide === undefined) {
-    return `latest version is ${latestVersion}\n${upgradeInstruction}`
-  }
-
-  return `latest version is ${latestVersion}\nMigration guide: ${migrationGuide}\n${upgradeInstruction}`
-}
-
-const getUpgradeInstruction = function (loadedFrom, origin) {
-  if (loadedFrom === 'package.json') {
-    return 'To upgrade this plugin, please update its version in "package.json"'
-  }
-
-  if (origin === 'ui') {
-    return 'To upgrade this plugin, please uninstall and re-install it from the Netlify plugins directory (https://app.netlify.com/plugins)'
-  }
-
-  return 'To upgrade this plugin, please remove it from "netlify.toml" and install it from the Netlify plugins directory instead (https://app.netlify.com/plugins)'
-}
-
-// Print a warning message when plugins are using a version that is too recent
-// and does not meet some `compatibility` expectations.
-// This can only happen when they are installed to `package.json`.
-export const logIncompatiblePlugins = function (logs, pluginsOptions) {
-  const incompatiblePlugins = pluginsOptions.filter(hasIncompatibleVersion).map(getIncompatiblePlugin)
-
-  if (incompatiblePlugins.length === 0) {
-    return
-  }
-
-  logWarningSubHeader(logs, 'Incompatible plugins')
-  logWarningArray(logs, incompatiblePlugins)
-}
-
-const hasIncompatibleVersion = function ({ pluginPackageJson: { version }, compatibleVersion, compatWarning }) {
-  return (
-    compatWarning !== '' &&
-    version !== undefined &&
-    compatibleVersion !== undefined &&
-    // Using only the major version prevents printing this warning message when
-    // a site is using the right `compatibility` version, but is using the most
-    // recent version due to the time gap between `npm publish` and the
-    // `plugins.json` update
-    isPreviousMajor(compatibleVersion, version)
-  )
-}
-
-const getIncompatiblePlugin = function ({
-  packageName,
-  pluginPackageJson: { version },
-  compatibleVersion,
-  compatWarning,
-}) {
-  const versionedPackage = getVersionedPackage(packageName, version)
-  return `${THEME.warningHighlightWords(
-    packageName,
-  )}${versionedPackage}: version ${compatibleVersion} is the most recent version compatible with ${compatWarning}`
-}
-
-// Make sure we handle `package.json` with `version` being either `undefined`
-// or an empty string
-const getVersionedPackage = function (packageName, version = '') {
-  return version === '' ? '' : `@${version}`
-}

package/src/log/messages/config.js

@@ -1,107 +0,0 @@
-import { cleanupConfig } from '@netlify/config'
-
-import { DEFAULT_FEATURE_FLAGS } from '../../core/feature_flags.js'
-import { omit } from '../../utils/omit.js'
-import { logMessage, logObject, logSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logFlags = function (logs, flags, { debug }) {
-  const flagsA = cleanFeatureFlags(flags)
-  const hiddenFlags = debug ? HIDDEN_DEBUG_FLAGS : HIDDEN_FLAGS
-  const flagsB = omit(flagsA, hiddenFlags)
-  logSubHeader(logs, 'Flags')
-  logObject(logs, flagsB)
-}
-
-// We only show feature flags related to `@netlify/build`.
-// Also, we only print enabled feature flags.
-const cleanFeatureFlags = function ({ featureFlags = {}, ...flags }) {
-  const cleanedFeatureFlags = Object.entries(featureFlags)
-    .filter(shouldPrintFeatureFlag)
-    .map(([featureFlagName]) => featureFlagName)
-  return cleanedFeatureFlags.length === 0 ? flags : { ...flags, featureFlags: cleanedFeatureFlags }
-}
-
-const shouldPrintFeatureFlag = function ([featureFlagName, enabled]) {
-  return enabled && featureFlagName in DEFAULT_FEATURE_FLAGS
-}
-
-// Hidden because the value is security-sensitive
-const SECURE_FLAGS = ['token', 'bugsnagKey', 'env', 'cachedConfig', 'defaultConfig']
-// Hidden because those are used in tests
-const TEST_FLAGS = ['buffer', 'telemetry']
-// Hidden because those are only used internally
-const INTERNAL_FLAGS = [
-  'nodePath',
-  'functionsDistDir',
-  'edgeFunctionsDistDir',
-  'defaultConfig',
-  'cachedConfigPath',
-  'sendStatus',
-  'saveConfig',
-  'statsd',
-  'framework',
-  'featureFlags',
-  'buildbotServerSocket',
-  'testOpts',
-  'siteId',
-  'context',
-  'branch',
-  'cwd',
-  'repositoryRoot',
-  'mode',
-  'apiHost',
-  'cacheDir',
-  'systemLogFile',
-  'timeline',
-]
-const HIDDEN_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS, ...INTERNAL_FLAGS]
-const HIDDEN_DEBUG_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS]
-
-export const logBuildDir = function (logs, buildDir) {
-  logSubHeader(logs, 'Current directory')
-  logMessage(logs, buildDir)
-}
-
-export const logConfigPath = function (logs, configPath = NO_CONFIG_MESSAGE) {
-  logSubHeader(logs, 'Config file')
-  logMessage(logs, configPath)
-}
-
-const NO_CONFIG_MESSAGE = 'No config file was defined: using default values.'
-
-export const logConfig = function ({ logs, netlifyConfig, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Resolved config')
-  logObject(logs, cleanupConfig(netlifyConfig))
-}
-
-export const logConfigOnUpdate = function ({ logs, netlifyConfig, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Updated config')
-  logObject(logs, cleanupConfig(netlifyConfig))
-}
-
-export const logConfigOnError = function ({ logs, netlifyConfig, severity }) {
-  if (netlifyConfig === undefined || severity === 'none') {
-    return
-  }
-
-  logMessage(logs, THEME.errorSubHeader('Resolved config'))
-  logObject(logs, cleanupConfig(netlifyConfig))
-}
-
-export const logContext = function (logs, context) {
-  if (context === undefined) {
-    return
-  }
-
-  logSubHeader(logs, 'Context')
-  logMessage(logs, context)
-}

package/src/log/messages/core.js

@@ -1,70 +0,0 @@
-import ansiEscapes from 'ansi-escapes'
-import prettyMs from 'pretty-ms'
-
-import { getFullErrorInfo } from '../../error/parse/parse.js'
-import { serializeLogError } from '../../error/parse/serialize_log.js'
-import { roundTimerToMillisecs } from '../../time/measure.js'
-import { ROOT_PACKAGE_JSON } from '../../utils/json.js'
-import { getLogHeaderFunc } from '../header_func.js'
-import { log, logMessage, logWarning, logHeader, logSubHeader, logWarningArray } from '../logger.js'
-import { logOldCliVersionError } from '../old_version.js'
-import { THEME } from '../theme.js'
-
-import { logConfigOnError } from './config.js'
-
-export const logBuildStart = function (logs) {
-  logHeader(logs, 'Netlify Build')
-  logSubHeader(logs, 'Version')
-  logMessage(logs, `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`)
-}
-
-export const logBuildError = function ({ error, netlifyConfig, mode, logs, debug, testOpts }) {
-  const fullErrorInfo = getFullErrorInfo({ error, colors: true, debug })
-  const { severity } = fullErrorInfo
-  const { title, body } = serializeLogError({ fullErrorInfo })
-  const logHeaderFunc = getLogHeaderFunc(error)
-  logHeaderFunc(logs, title)
-  logMessage(logs, `\n${body}\n`)
-  logConfigOnError({ logs, netlifyConfig, severity })
-  logOldCliVersionError({ mode, testOpts })
-}
-
-export const logBuildSuccess = function (logs) {
-  logHeader(logs, 'Netlify Build Complete')
-  logMessage(logs, '')
-}
-
-export const logTimer = function (logs, durationNs, timerName) {
-  const durationMs = roundTimerToMillisecs(durationNs)
-  const duration = prettyMs(durationMs)
-  log(logs, THEME.dimWords(`(${timerName} completed in ${duration})`))
-}
-
-export const logMissingSideFile = function (logs, sideFile, publish) {
-  logWarning(
-    logs,
-    `
-A "${sideFile}" file is present in the repository but is missing in the publish directory "${publish}".`,
-  )
-}
-
-// @todo use `terminal-link` (https://github.com/sindresorhus/terminal-link)
-// instead of `ansi-escapes` once
-// https://github.com/jamestalmage/supports-hyperlinks/pull/12 is fixed
-export const logLingeringProcesses = function (logs, commands) {
-  logWarning(
-    logs,
-    `
-The build completed successfully, but the following processes were still running:
-`,
-  )
-  logWarningArray(logs, commands)
-  logWarning(
-    logs,
-    `
-These processes have been terminated. In case this creates a problem for your build, refer to this ${ansiEscapes.link(
-      'article',
-      'https://answers.netlify.com/t/support-guide-how-to-address-the-warning-message-related-to-terminating-processes-in-builds/35277',
-    )} for details about why this process termination happens and how to fix it.`,
-  )
-}