@netlify/build 29.0.1-rc → 29.0.2

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

package/src/error/monitor/report.js

@@ -1,138 +0,0 @@
-import { type as osType, freemem, totalmem } from 'os'
-import { promisify } from 'util'
-
-import osName from 'os-name'
-
-import { getEnvMetadata } from '../../env/metadata.js'
-import { log } from '../../log/logger.js'
-import { parseErrorInfo } from '../parse/parse.js'
-import { getHomepage } from '../parse/plugin.js'
-
-import { getLocationMetadata } from './location.js'
-import { normalizeGroupingMessage } from './normalize.js'
-import { printEventForTest } from './print.js'
-
-// Report a build failure for monitoring purpose
-export const reportBuildError = async function ({ error, errorMonitor, childEnv, logs, testOpts }) {
-  if (errorMonitor === undefined) {
-    return
-  }
-
-  const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error)
-  const severityA = getSeverity(severity, errorInfo)
-  const groupA = getGroup(group, errorInfo)
-  const groupingHash = getGroupingHash(groupA, error, type, errorInfo)
-  const metadata = getMetadata(errorInfo, childEnv, groupingHash)
-  const app = getApp()
-  const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app })
-
-  const errorName = updateErrorName(error, type)
-  try {
-    await reportError({ errorMonitor, error, logs, testOpts, eventProps })
-  } finally {
-    error.name = errorName
-  }
-}
-
-// Plugin authors test their plugins as local plugins. Errors there are more
-// like development errors, and should be reported as `info` only.
-const getSeverity = function (severity, { location: { loadedFrom } = {} }) {
-  if (loadedFrom === 'local' || severity === 'none') {
-    return 'info'
-  }
-
-  return severity
-}
-
-const getGroup = function (group, errorInfo) {
-  if (typeof group !== 'function') {
-    return group
-  }
-
-  return group(errorInfo)
-}
-
-const getGroupingHash = function (group, error, type, errorInfo = {}) {
-  // If the error has a `normalizedMessage`, we use it as the grouping hash.
-  if (errorInfo.normalizedMessage) {
-    return errorInfo.normalizedMessage
-  }
-
-  const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error)
-  const messageA = normalizeGroupingMessage(message, type)
-  return `${group}\n${messageA}`
-}
-
-const getMetadata = function ({ location, plugin, tsConfig }, childEnv, groupingHash) {
-  const pluginMetadata = getPluginMetadata({ location, plugin })
-  const envMetadata = getEnvMetadata(childEnv)
-  const locationMetadata = getLocationMetadata(location, envMetadata)
-  return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } }
-}
-
-const getPluginMetadata = function ({ location, plugin }) {
-  if (plugin === undefined) {
-    return {}
-  }
-
-  const { pluginPackageJson, ...pluginA } = plugin
-  const homepage = getHomepage(pluginPackageJson, location)
-  return { plugin: { ...pluginA, homepage }, pluginPackageJson }
-}
-
-const getApp = function () {
-  return {
-    osName: osType(),
-    osVersion: osName(),
-    freeMemory: freemem(),
-    totalMemory: totalmem(),
-  }
-}
-
-// `error.name` is shown proeminently in the Bugsnag UI. We need to update it to
-// match error `type` since it is more granular and useful.
-// But we change it back after Bugsnag is done reporting.
-const updateErrorName = function (error, type) {
-  const { name } = error
-  // This might fail if `name` is a getter or is non-writable.
-  try {
-    error.name = type
-  } catch {}
-  return name
-}
-
-const reportError = async function ({ errorMonitor, error, logs, testOpts, eventProps }) {
-  if (testOpts.errorMonitor) {
-    printEventForTest(error, eventProps, logs)
-    return
-  }
-
-  try {
-    await promisify(errorMonitor.notify)(error, (event) => onError(event, eventProps))
-    // Failsafe
-  } catch {
-    log(logs, `Error monitor could not notify\n${error.stack}`)
-  }
-}
-
-const getEventProps = function ({ severity, group, groupingHash, metadata, app }) {
-  // `unhandled` is used to calculate Releases "stabiity score", which is
-  // basically the percentage of unhandled errors. Since we handle all errors,
-  // we need to implement this according to error types.
-  const unhandled = severity === 'error'
-  return { severity, context: group, groupingHash, _metadata: metadata, app, unhandled }
-}
-
-// Add more information to Bugsnag events
-const onError = function (event, eventProps) {
-  // Bugsnag client requires directly mutating the `event`
-  // eslint-disable-next-line fp/no-mutating-assign
-  Object.assign(event, {
-    ...eventProps,
-    unhandled: event.unhandled || eventProps.unhandled,
-    // eslint-disable-next-line no-underscore-dangle
-    _metadata: { ...event._metadata, ...eventProps._metadata },
-    app: { ...event.app, ...eventProps.app },
-  })
-  return true
-}

package/src/error/monitor/start.js

@@ -1,69 +0,0 @@
-import { fileURLToPath } from 'url'
-
-import Bugsnag from '@bugsnag/js'
-import memoizeOne from 'memoize-one'
-
-import { log } from '../../log/logger.js'
-import { ROOT_PACKAGE_JSON } from '../../utils/json.js'
-
-const projectRoot = fileURLToPath(new URL('../../..', import.meta.url))
-
-// Start a client to monitor errors
-export const startErrorMonitor = function ({ flags: { mode }, logs, bugsnagKey }) {
-  if (!bugsnagKey) {
-    return
-  }
-
-  const isTest = isBugsnagTest(bugsnagKey)
-  const releaseStage = getReleaseStage(mode)
-  const logger = getLogger(logs, isTest)
-  try {
-    const errorMonitor = startBugsnag({
-      apiKey: bugsnagKey,
-      appVersion: `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`,
-      appType: ROOT_PACKAGE_JSON.name,
-      releaseStage,
-      logger,
-      projectRoot,
-    })
-
-    // Allows knowing the percentage of failed builds per release
-    if (!isTest) {
-      errorMonitor.startSession()
-    }
-
-    return errorMonitor
-    // Failsafe
-  } catch (error) {
-    log(logs, `Error monitor could not start\n${error.stack}`)
-  }
-}
-
-const isBugsnagTest = function (bugsnagKey) {
-  return bugsnagKey === BUGSNAG_TEST_KEY
-}
-
-const BUGSNAG_TEST_KEY = '00000000000000000000000000000000'
-
-// Bugsnag.start() caches a global instance and warns on duplicate calls.
-// This ensures the warning message is not shown when calling the main function
-// several times.
-const startBugsnag = memoizeOne(Bugsnag.start.bind(Bugsnag), () => true)
-
-// Based the release stage on the `mode`
-const getReleaseStage = function (mode = DEFAULT_RELEASE_STAGE) {
-  return mode
-}
-
-const DEFAULT_RELEASE_STAGE = 'unknown'
-
-// We don't want Bugsnag logs except on warnings/errors.
-// We also want to use our own `log` utility, unprefixed.
-// In tests, we don't print Bugsnag because it sometimes randomly fails to
-// send sessions, which prints warning messags in test snapshots.
-const getLogger = function (logs, isTest) {
-  const logFunc = isTest ? noop : log.bind(null, logs)
-  return { debug: noop, info: noop, warn: logFunc, error: logFunc }
-}
-
-const noop = function () {}

package/src/error/parse/clean_stack.js

@@ -1,87 +0,0 @@
-import { cwd } from 'process'
-
-import cleanStack from 'clean-stack'
-import stripAnsi from 'strip-ansi'
-
-// Clean stack traces:
-//  - remove our internal code, e.g. the logic spawning plugins
-//  - remove node modules and Node.js internals
-//  - strip process.cwd()
-//  - remove colors
-// Keep non stack trace lines as is.
-// We do not use libraries that patch `Error.prepareStackTrace()` because they
-// tend to create issues.
-export const cleanStacks = function ({ stack, rawStack, debug }) {
-  if (stack === undefined) {
-    return
-  }
-
-  // Internal errors / bugs keep their full stack trace
-  // Same in debug mode
-  if (rawStack || debug) {
-    return stack
-  }
-
-  return stack.split('\n').reduce(cleanStackLine, '').replace(INITIAL_NEWLINES, '')
-}
-
-const cleanStackLine = function (lines, line) {
-  const lineA = line.replace(getCwd(), '')
-  const lineB = stripAnsi(lineA)
-
-  if (!STACK_LINE_REGEXP.test(lineB)) {
-    return `${lines}\n${lineA}`
-  }
-
-  if (shouldRemoveStackLine(lineB)) {
-    return lines
-  }
-
-  const lineC = cleanStack(lineB)
-
-  if (lineC === '') {
-    return lines
-  }
-
-  return `${lines}\n${lineC}`
-}
-
-// `process.cwd()` can sometimes fail: directory name too long, current
-// directory has been removed, access denied.
-const getCwd = function () {
-  try {
-    return cwd()
-  } catch {
-    return ''
-  }
-}
-
-// Check if a line is part of a stack trace
-const STACK_LINE_REGEXP = /^\s+at /
-
-const shouldRemoveStackLine = function (line) {
-  const lineA = normalizePathSlashes(line)
-  return INTERNAL_STACK_STRINGS.some((stackString) => lineA.includes(stackString)) || INTERNAL_STACK_REGEXP.test(lineA)
-}
-
-const INTERNAL_STACK_STRINGS = [
-  // Anonymous function
-  '<anonymous>',
-  '(index 0)',
-  // nyc internal code
-  'node_modules/append-transform',
-  'node_modules/signal-exit',
-  // Node internals
-  '(node:',
-]
-
-// This is only needed for local builds and tests
-const INTERNAL_STACK_REGEXP = /(packages|@netlify)\/build\/(src\/|tests\/helpers\/|tests\/.*\/tests.js|node_modules)/
-
-const INITIAL_NEWLINES = /^\n+/
-
-const normalizePathSlashes = function (line) {
-  return line.replace(BACKLASH_REGEXP, '/')
-}
-
-const BACKLASH_REGEXP = /\\/g

package/src/error/parse/location.js

@@ -1,62 +0,0 @@
-import { getBuildCommandDescription, getPluginOrigin } from '../../log/description.js'
-
-// Retrieve an error's location to print in logs.
-// Each error type has its own logic (or none if there's no location to print).
-export const getLocationInfo = function ({ stack, location, locationType }) {
-  // No location to print
-  if (locationType === undefined && stack === undefined) {
-    return
-  }
-
-  // The location is only the stack trace
-  if (locationType === undefined) {
-    return stack
-  }
-
-  const locationString = LOCATIONS[locationType](location)
-  return [locationString, stack].filter(Boolean).join('\n')
-}
-
-const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin }) {
-  const description = getBuildCommandDescription(buildCommandOrigin)
-  return `In ${description}:
-${buildCommand}`
-}
-
-const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
-  if (functionType === 'edge') {
-    return 'While bundling edge function'
-  }
-
-  return `While bundling function "${functionName}"`
-}
-
-const getCoreStepLocation = function ({ coreStepName }) {
-  return `During ${coreStepName}`
-}
-
-const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
-  const eventMessage = getEventMessage(event)
-  const pluginOrigin = getPluginOrigin(loadedFrom, origin)
-  return `${eventMessage} "${packageName}" ${pluginOrigin}`
-}
-
-const getEventMessage = function (event) {
-  if (event === 'load') {
-    return `While loading`
-  }
-
-  return `In "${event}" event in`
-}
-
-const getApiLocation = function ({ endpoint, parameters }) {
-  return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`
-}
-
-const LOCATIONS = {
-  buildCommand: getBuildCommandLocation,
-  functionsBundling: getFunctionsBundlingLocation,
-  coreStep: getCoreStepLocation,
-  buildFail: getBuildFailLocation,
-  api: getApiLocation,
-}

package/src/error/parse/normalize.js

@@ -1,29 +0,0 @@
-// Ensure error is an `Error` instance.
-// If is an `Error` instance but is missing usual `Error` properties, we make
-// sure its static properties are preserved.
-export const normalizeError = function (error) {
-  if (Array.isArray(error)) {
-    return normalizeArray(error)
-  }
-
-  if (!(error instanceof Error)) {
-    return new Error(String(error))
-  }
-
-  if (typeof error.message !== 'string') {
-    error.message = String(error)
-  }
-
-  if (typeof error.stack !== 'string') {
-    Error.captureStackTrace(error, normalizeError)
-  }
-
-  return error
-}
-
-// Some libraries throw arrays of Errors
-const normalizeArray = function (errorArray) {
-  const [error, ...errors] = errorArray.map(normalizeError)
-  error.errors = errors
-  return error
-}

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