@netlify/build 29.0.1-rc → 29.0.2

package/src/error/parse/stack.js

@@ -1,43 +0,0 @@
-import { cleanStacks } from './clean_stack.js'
-
-// Retrieve the stack trace
-export const getStackInfo = function ({ message, stack, stackType, rawStack, severity, debug }) {
-  const { message: messageA, stack: stackA } = splitStackInfo({ message, stack, stackType })
-  const messageB = severity === 'none' ? messageA.replace(SUCCESS_ERROR_NAME, '') : messageA
-  const stackB = cleanStacks({ stack: stackA, rawStack, debug })
-  return { message: messageB, stack: stackB }
-}
-
-const splitStackInfo = function ({ message, stack, stackType }) {
-  // Some errors should not show any stack trace
-  if (stackType === 'none') {
-    return { message }
-  }
-
-  // Some errors have their stack trace inside `error.message` instead of
-  // `error.stack` due to IPC
-  if (stackType === 'message') {
-    return splitStack(message)
-  }
-
-  return splitStack(stack)
-}
-
-const splitStack = function (string) {
-  const lines = string.split('\n')
-  const stackIndex = lines.findIndex(isStackTrace)
-
-  if (stackIndex === -1) {
-    return { message: string }
-  }
-
-  const messageA = lines.slice(0, stackIndex).join('\n')
-  const stackA = lines.slice(stackIndex).join('\n')
-  return { message: messageA, stack: stackA }
-}
-
-const isStackTrace = function (line) {
-  return line.trim().startsWith('at ')
-}
-
-const SUCCESS_ERROR_NAME = 'Error: '

package/src/error/type.js

@@ -1,189 +0,0 @@
-// Retrieve error-type specific information
-export const getTypeInfo = function ({ type }) {
-  const typeA = TYPES[type] === undefined ? DEFAULT_TYPE : type
-  return { type: typeA, ...TYPES[typeA] }
-}
-
-// List of error types, and their related properties
-// Related to build error logs:
-//  - `showInBuildLog`: `true` when we want this error to show in build logs (defaults to true)
-//  - `title`: main title shown in build error logs and in the UI (statuses)
-//  - `locationType`: retrieve a human-friendly location of the error, printed
-//    in build error logs
-//  - `showErrorProps`: `true` when the `Error` instance static properties
-//    should be printed in build error logs. Only useful when the `Error`
-//    instance was not created by us.
-//  - `rawStack`: `true` when the stack trace should be cleaned up
-//  - `stackType`: how the stack trace should appear in build error logs:
-//      - `none`: not printed
-//      - `stack`: printed as is
-//      - `message`: printed as is, but taken from `error.message`.
-//        Used when `error.stack` is not being correct due to the error being
-//        passed between different processes.
-//  - `severity`: error severity (also used by Bugsnag):
-//      - `success`: build success
-//      - `none`: not an error, e.g. build cancellation
-//      - `info`: user error
-//      - `warning`: community plugin error
-//      - `error`: system error, including core plugin error
-// Related to Bugsnag:
-//  - `group`: main title shown in Bugsnag. Also used to group errors together
-//    in Bugsnag, combined with `error.message`.
-//    Defaults to `title`.
-// New error types should be added to Bugsnag since we use it for automated
-// monitoring (through its Slack integration). The steps in Bugsnag are:
-//  - Create a new bookmark. Try to re-use the search filter of an existing
-//    bookmark with a similar error type, but only changing the `errorClass`.
-//    Make sure to check the box "Share with my team".
-//  - Add the `errorClass` to the search filter of either the "All warnings" or
-//    "All errors" bookmark depending on whether we should get notified on Slack
-//    for new errors of that type. You must use the bookmark menu action "Update
-//    with current filters"
-const TYPES = {
-  // Plugin called `utils.build.cancelBuild()`
-  cancelBuild: {
-    title: ({ location: { packageName } }) => `Build canceled by ${packageName}`,
-    stackType: 'stack',
-    locationType: 'buildFail',
-    severity: 'none',
-  },
-
-  // User configuration error (`@netlify/config`, wrong Node.js version)
-  resolveConfig: {
-    title: 'Configuration error',
-    stackType: 'none',
-    severity: 'info',
-  },
-
-  // Error while installing user packages (missing plugins, local plugins or functions dependencies)
-  dependencies: {
-    title: 'Dependencies installation error',
-    stackType: 'none',
-    severity: 'info',
-  },
-
-  // User misconfigured a plugin
-  pluginInput: {
-    title: ({ location: { packageName, input } }) => `Plugin "${packageName}" invalid input "${input}"`,
-    stackType: 'none',
-    locationType: 'buildFail',
-    severity: 'info',
-  },
-
-  // `build.command` non-0 exit code
-  buildCommand: {
-    title: '"build.command" failed',
-    group: ({ location: { buildCommand } }) => buildCommand,
-    stackType: 'message',
-    locationType: 'buildCommand',
-    severity: 'info',
-  },
-
-  // User error during Functions bundling
-  functionsBundling: {
-    title: ({ location: { functionName, functionType } }) => {
-      if (functionType === 'edge') {
-        return 'Bundling of edge function failed'
-      }
-
-      return `Bundling of function "${functionName}" failed`
-    },
-    group: ({ location: { functionType = 'serverless' } }) => `Bundling of ${functionType} function failed`,
-    stackType: 'none',
-    locationType: 'functionsBundling',
-    severity: 'info',
-  },
-
-  // Plugin called `utils.build.failBuild()`
-  failBuild: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
-    stackType: 'stack',
-    locationType: 'buildFail',
-    severity: 'info',
-  },
-
-  // Plugin called `utils.build.failPlugin()`
-  failPlugin: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
-    stackType: 'stack',
-    locationType: 'buildFail',
-    severity: 'info',
-  },
-
-  // Plugin has an invalid shape
-  pluginValidation: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-    stackType: 'stack',
-    locationType: 'buildFail',
-    severity: 'warning',
-  },
-
-  // Plugin threw an uncaught exception
-  pluginInternal: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-    stackType: 'stack',
-    showErrorProps: true,
-    rawStack: true,
-    locationType: 'buildFail',
-    severity: 'warning',
-  },
-
-  // Bug while orchestrating child processes
-  ipc: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-    stackType: 'none',
-    locationType: 'buildFail',
-    severity: 'warning',
-  },
-
-  // Core plugin internal error
-  corePlugin: {
-    title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-    stackType: 'stack',
-    showErrorProps: true,
-    rawStack: true,
-    locationType: 'buildFail',
-    severity: 'error',
-  },
-
-  // Core step internal error
-  coreStep: {
-    title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
-    stackType: 'stack',
-    showErrorProps: true,
-    rawStack: true,
-    locationType: 'coreStep',
-    severity: 'error',
-  },
-
-  // Request error when `@netlify/build` was calling Netlify API
-  api: {
-    title: ({ location: { endpoint } }) => `API error on "${endpoint}"`,
-    stackType: 'message',
-    showErrorProps: true,
-    locationType: 'api',
-    severity: 'error',
-  },
-
-  // `@netlify/build` threw an uncaught exception
-  exception: {
-    title: 'Core internal error',
-    stackType: 'stack',
-    showErrorProps: true,
-    rawStack: true,
-    severity: 'error',
-  },
-
-  // Errors related with the telemetry output
-  telemetry: {
-    showInBuildLog: false,
-    title: 'Telemetry error',
-    stackType: 'stack',
-    showErrorProps: true,
-    rawStack: true,
-    severity: 'error',
-  },
-}
-
-// When no error type matches, it's an uncaught exception, i.e. a bug
-const DEFAULT_TYPE = 'exception'

package/src/install/functions.js

@@ -1,28 +0,0 @@
-import { dirname } from 'path'
-
-import readdirp from 'readdirp'
-
-import { logInstallFunctionDependencies } from '../log/messages/install.js'
-
-import { installDependencies } from './main.js'
-
-// Install dependencies of Netlify Functions
-export const installFunctionDependencies = async function (functionsSrc, isLocal) {
-  const packagePaths = await getPackagePaths(functionsSrc)
-  if (packagePaths.length === 0) {
-    return
-  }
-
-  logInstallFunctionDependencies()
-
-  const packageRoots = packagePaths.map(getPackageRoot)
-  await Promise.all(packageRoots.map((packageRoot) => installDependencies({ packageRoot, isLocal })))
-}
-
-const getPackagePaths = function (functionsSrc) {
-  return readdirp.promise(functionsSrc, { depth: 1, fileFilter: 'package.json' })
-}
-
-const getPackageRoot = function ({ fullPath }) {
-  return dirname(fullPath)
-}

package/src/install/local.js

@@ -1,62 +0,0 @@
-import { packageDirectory } from 'pkg-dir'
-
-import { logInstallLocalPluginsDeps } from '../log/messages/install.js'
-
-import { installDependencies } from './main.js'
-
-// Install dependencies of local plugins.
-// Users must add this plugin to their `netlify.toml` `plugins` to use this
-// feature. We don't want to provide it by default because this makes build
-// slow and buggy.
-export const installLocalPluginsDependencies = async function ({ plugins, pluginsOptions, buildDir, mode, logs }) {
-  if (!plugins.some(isLocalInstallOptIn)) {
-    return
-  }
-
-  const localPluginsOptions = getLocalPluginsOptions(pluginsOptions)
-  if (localPluginsOptions.length === 0) {
-    return
-  }
-
-  const localPluginsOptionsA = await removeMainRoot(localPluginsOptions, buildDir)
-  if (localPluginsOptionsA.length === 0) {
-    return
-  }
-
-  logInstallLocalPluginsDeps(logs, localPluginsOptionsA)
-  await Promise.all(
-    localPluginsOptionsA.map(({ packageDir }) =>
-      installDependencies({ packageRoot: packageDir, isLocal: mode !== 'buildbot' }),
-    ),
-  )
-}
-
-const isLocalInstallOptIn = function (plugin) {
-  return plugin.package === LOCAL_INSTALL_PLUGIN_NAME
-}
-
-export const LOCAL_INSTALL_PLUGIN_NAME = '@netlify/plugin-local-install-core'
-
-// Core plugins and non-local plugins already have their dependencies installed
-const getLocalPluginsOptions = function (pluginsOptions) {
-  return pluginsOptions.filter(isLocalPlugin).filter(isUnique).filter(hasPackageDir)
-}
-
-const isLocalPlugin = function ({ loadedFrom }) {
-  return loadedFrom === 'local'
-}
-
-// Remove duplicates
-const isUnique = function ({ packageDir }, index, pluginsOptions) {
-  return pluginsOptions.slice(index + 1).every((pluginOption) => pluginOption.packageDir !== packageDir)
-}
-
-const hasPackageDir = function ({ packageDir }) {
-  return packageDir !== undefined
-}
-
-// We only install dependencies of local plugins that have their own `package.json`
-const removeMainRoot = async function (localPluginsOptions, buildDir) {
-  const mainPackageDir = await packageDirectory({ cwd: buildDir })
-  return localPluginsOptions.filter(({ packageDir }) => packageDir !== mainPackageDir)
-}

package/src/install/main.js

@@ -1,81 +0,0 @@
-import { homedir } from 'os'
-
-import { execa } from 'execa'
-import { pathExists } from 'path-exists'
-
-import { addErrorInfo } from '../error/info.js'
-
-// Install Node.js dependencies in a specific directory
-export const installDependencies = function ({ packageRoot, isLocal }) {
-  return runCommand({ packageRoot, isLocal, type: 'install' })
-}
-
-// Add new Node.js dependencies, with exact semver ranges
-export const addExactDependencies = function ({ packageRoot, isLocal, packages }) {
-  return runCommand({ packageRoot, packages, isLocal, type: 'addExact' })
-}
-
-const runCommand = async function ({ packageRoot, packages = [], isLocal, type }) {
-  try {
-    const [command, ...args] = await getCommand({ packageRoot, type, isLocal })
-    await execa(command, [...args, ...packages], { cwd: packageRoot, all: true })
-  } catch (error) {
-    const message = getErrorMessage(error.all)
-    const errorA = new Error(`Error while installing dependencies in ${packageRoot}\n${message}`)
-    addErrorInfo(errorA, { type: 'dependencies' })
-    throw errorA
-  }
-}
-
-// Retrieve the shell command to install or add dependencies
-const getCommand = async function ({ packageRoot, type, isLocal }) {
-  const manager = await getManager(type, packageRoot)
-  const command = COMMANDS[manager][type]
-  const commandA = addYarnCustomCache(command, manager, isLocal)
-  return commandA
-}
-
-const getManager = async function (type, packageRoot) {
-  // `addDependencies()` always uses npm
-  if (type === 'addExact') {
-    return 'npm'
-  }
-
-  if (await pathExists(`${packageRoot}/yarn.lock`)) {
-    return 'yarn'
-  }
-
-  return 'npm'
-}
-
-const COMMANDS = {
-  npm: {
-    addExact: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund', '--save-exact'],
-    install: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund'],
-  },
-  yarn: {
-    install: ['yarn', 'install', '--no-progress', '--non-interactive'],
-  },
-}
-
-// In CI, yarn uses a custom cache folder
-const addYarnCustomCache = function (command, manager, isLocal) {
-  if (manager !== 'yarn' || isLocal) {
-    return command
-  }
-
-  return [...command, '--cache-folder', YARN_CI_CACHE_DIR]
-}
-
-const YARN_CI_CACHE_DIR = `${homedir()}/.yarn_cache`
-
-// Retrieve message to add to install errors
-const getErrorMessage = function (allOutput) {
-  return allOutput.split('\n').filter(isNotNpmLogMessage).join('\n')
-}
-
-// Debug logs shown at the end of npm errors is not useful in Netlify Build
-const isNotNpmLogMessage = function (line) {
-  return NPM_LOG_MESSAGES.every((message) => !line.includes(message))
-}
-const NPM_LOG_MESSAGES = ['complete log of this run', '-debug.log']

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
-}