@netlify/build 27.18.3 → 27.18.5-rc

package/src/error/parse/parse.js

@@ -1,97 +0,0 @@
-import { serializeObject } from '../../log/serialize.js'
-import { getErrorInfo } from '../info.js'
-import { getTypeInfo } from '../type.js'
-
-import { getLocationInfo } from './location.js'
-import { normalizeError } from './normalize.js'
-import { getPluginInfo } from './plugin.js'
-import { getErrorProps } from './properties.js'
-import { getStackInfo } from './stack.js'
-
-// Add additional type-specific error information
-export const getFullErrorInfo = function ({ error, colors, debug }) {
-  const basicErrorInfo = parseErrorInfo(error)
-  const {
-    message,
-    stack,
-    errorProps,
-    errorInfo,
-    errorInfo: { location = {}, plugin = {}, tsConfig },
-    severity,
-    title,
-    stackType,
-    locationType,
-    showErrorProps,
-    rawStack,
-  } = basicErrorInfo
-
-  const titleA = getTitle(title, errorInfo)
-
-  const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, severity, debug })
-
-  const pluginInfo = getPluginInfo(plugin, location)
-  const tsConfigInfo = getTsConfigInfo(tsConfig)
-  const locationInfo = getLocationInfo({ stack: stackA, location, locationType })
-  const errorPropsA = getErrorProps({ errorProps, showErrorProps, colors })
-
-  return {
-    ...basicErrorInfo,
-    title: titleA,
-    message: messageA,
-    tsConfigInfo,
-    pluginInfo,
-    locationInfo,
-    errorProps: errorPropsA,
-  }
-}
-
-// Serialize the `tsConfig` error information
-const getTsConfigInfo = function (tsConfig) {
-  if (tsConfig === undefined) {
-    return
-  }
-
-  return serializeObject(tsConfig)
-}
-
-// Parse error instance into all the basic properties containing information
-export const parseErrorInfo = function (error) {
-  const { message, stack, ...errorProps } = normalizeError(error)
-  const [errorInfo, errorPropsA] = getErrorInfo(errorProps)
-  const {
-    type,
-    severity,
-    title,
-    group,
-    stackType,
-    locationType,
-    showErrorProps,
-    showInBuildLog = true,
-    rawStack,
-  } = getTypeInfo(errorInfo)
-  const basicErrorInfo = {
-    message,
-    stack,
-    errorProps: errorPropsA,
-    errorInfo,
-    type,
-    severity,
-    title,
-    group,
-    stackType,
-    locationType,
-    showInBuildLog,
-    showErrorProps,
-    rawStack,
-  }
-  return basicErrorInfo
-}
-
-// Retrieve title to print in logs
-const getTitle = function (title, errorInfo) {
-  if (typeof title !== 'function') {
-    return title
-  }
-
-  return title(errorInfo)
-}

package/src/error/parse/plugin.js

@@ -1,70 +0,0 @@
-// Retrieve plugin's package.json details to include in error messages.
-// Please note `pluginPackageJson` has been normalized by `normalize-package-data`.
-export const getPluginInfo = function ({ pluginPackageJson = {} }, { packageName, loadedFrom }) {
-  if (Object.keys(pluginPackageJson).length === 0) {
-    return
-  }
-
-  return Object.entries(FIELDS)
-    .map(([name, getField]) => serializeField({ name, getField, pluginPackageJson, packageName, loadedFrom }))
-    .filter(Boolean)
-    .join('\n')
-}
-
-// Serialize a single package.json field
-const serializeField = function ({ name, getField, pluginPackageJson, packageName, loadedFrom }) {
-  const field = getField(pluginPackageJson, { packageName, loadedFrom })
-  if (field === undefined) {
-    return
-  }
-
-  const nameA = `${name}:`.padEnd(NAME_PADDING)
-  return `${nameA}${field}`
-}
-
-const NAME_PADDING = 16
-
-const getPackage = function (pluginPackageJson, { packageName }) {
-  return packageName
-}
-
-const getVersion = function ({ version }) {
-  if (version === '') {
-    return
-  }
-
-  return version
-}
-
-export const getHomepage = function (pluginPackageJson = {}, { loadedFrom } = {}) {
-  return (
-    getRepository(pluginPackageJson) ||
-    getNpmLink(pluginPackageJson, { loadedFrom }) ||
-    getIssuesLink(pluginPackageJson)
-  )
-}
-
-const getRepository = function ({ repository: { url } = {} }) {
-  return url
-}
-
-const getNpmLink = function ({ name }, { loadedFrom }) {
-  if (!name || loadedFrom === 'local') {
-    return
-  }
-
-  return `https://www.npmjs.com/package/${name}`
-}
-
-const getIssuesLink = function ({ bugs: { url } = {} }) {
-  return url
-}
-
-// List of package.json to serialize
-const FIELDS = {
-  Package: getPackage,
-  Version: getVersion,
-  Repository: getRepository,
-  'npm link': getNpmLink,
-  'Report issues': getIssuesLink,
-}

package/src/error/parse/properties.js

@@ -1,23 +0,0 @@
-import { inspect } from 'util'
-
-import { omit } from '../../utils/omit.js'
-
-// In uncaught exceptions, print error static properties
-export const getErrorProps = function ({ errorProps, showErrorProps, colors }) {
-  if (!showErrorProps) {
-    return
-  }
-
-  const errorPropsA = omit(errorProps, CLEANED_ERROR_PROPS)
-
-  if (Object.keys(errorPropsA).length === 0) {
-    return
-  }
-
-  return inspect(errorPropsA, { colors, depth: INSPECT_MAX_DEPTH })
-}
-
-const INSPECT_MAX_DEPTH = 5
-
-// Remove error static properties that should not be logged
-const CLEANED_ERROR_PROPS = ['requireStack']

package/src/error/parse/serialize_log.js

@@ -1,42 +0,0 @@
-import { THEME } from '../../log/theme.js'
-
-// Serialize an error object into a title|body string to print in logs
-export const serializeLogError = function ({
-  fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps },
-}) {
-  const body = getBody({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity })
-  return { title, body }
-}
-
-const getBody = function ({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity }) {
-  if (severity === 'none') {
-    return message
-  }
-
-  return Object.entries({
-    message,
-    tsConfigInfo,
-    pluginInfo,
-    locationInfo,
-    errorProps,
-  })
-    .filter(blockHasValue)
-    .map(serializeBlock)
-    .join('\n\n')
-}
-
-const blockHasValue = function ([, value]) {
-  return value !== undefined
-}
-
-const serializeBlock = function ([key, value]) {
-  return `${THEME.errorSubHeader(LOG_BLOCK_NAMES[key])}\n${value}`
-}
-
-const LOG_BLOCK_NAMES = {
-  message: 'Error message',
-  pluginInfo: 'Plugin details',
-  locationInfo: 'Error location',
-  tsConfigInfo: 'TypeScript configuration',
-  errorProps: 'Error properties',
-}

package/src/error/parse/serialize_status.js

@@ -1,23 +0,0 @@
-// Serialize an error object to `statuses` properties
-export const serializeErrorStatus = function ({ fullErrorInfo: { title, message, locationInfo, errorProps }, state }) {
-  const text = getText({ locationInfo, errorProps })
-  return { state, title, summary: message, text }
-}
-
-const getText = function ({ locationInfo, errorProps }) {
-  const parts = [locationInfo, getErrorProps(errorProps)].filter(Boolean)
-
-  if (parts.length === 0) {
-    return
-  }
-
-  return parts.join('\n\n')
-}
-
-const getErrorProps = function (errorProps) {
-  if (errorProps === undefined) {
-    return
-  }
-
-  return `Error properties:\n${errorProps}`
-}

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']