@netlify/build 27.18.3 → 27.18.5-rc

package/src/status/report.js

@@ -1,137 +0,0 @@
-import { handleBuildError } from '../error/handle.js'
-import { logStatuses } from '../log/messages/status.js'
-
-import { removeStatusesColors } from './colors.js'
-
-// Report plugin statuses to the console and API
-export const reportStatuses = async function ({
-  statuses,
-  childEnv,
-  api,
-  mode,
-  pluginsOptions,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-}) {
-  const finalStatuses = getFinalStatuses({ statuses, pluginsOptions })
-  if (finalStatuses.length === 0) {
-    return
-  }
-
-  const statusesA = removeStatusesColors(finalStatuses)
-  printStatuses({ statuses: statusesA, mode, logs })
-  await sendApiStatuses({
-    statuses: statusesA,
-    childEnv,
-    api,
-    mode,
-    netlifyConfig,
-    errorMonitor,
-    deployId,
-    logs,
-    debug,
-    sendStatus,
-    testOpts,
-  })
-}
-
-// Some plugins might not have completed due to a build error.
-// In that case, we add a dummy plugin run with state "skipped".
-// This allows the API to know both plugins that have completed and only started
-const getFinalStatuses = function ({ statuses = [], pluginsOptions }) {
-  return pluginsOptions.map(({ packageName }) => getPluginStatus(packageName, statuses))
-}
-
-const getPluginStatus = function (packageName, statuses) {
-  const pluginStatus = statuses.find((status) => status.packageName === packageName)
-
-  if (pluginStatus !== undefined) {
-    return pluginStatus
-  }
-
-  return { packageName, state: 'skipped' }
-}
-
-// When not in production, print statuses to console.
-// Only print successful ones, since errors are logged afterwards.
-const printStatuses = function ({ statuses, mode, logs }) {
-  if (mode === 'buildbot') {
-    return
-  }
-
-  const successStatuses = statuses.filter(shouldPrintStatus)
-
-  if (successStatuses.length === 0) {
-    return
-  }
-
-  logStatuses(logs, successStatuses)
-}
-
-const shouldPrintStatus = function ({ state, summary }) {
-  return state === 'success' && summary !== undefined
-}
-
-// In production, send statuses to the API
-const sendApiStatuses = async function ({
-  statuses,
-  childEnv,
-  api,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-}) {
-  if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !deployId) {
-    return
-  }
-
-  await Promise.all(
-    statuses.map((status) =>
-      sendApiStatus({ api, status, childEnv, mode, netlifyConfig, errorMonitor, deployId, logs, debug, testOpts }),
-    ),
-  )
-}
-
-const sendApiStatus = async function ({
-  api,
-  status: { packageName, version, state, event, title, summary, text, extraData },
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  deployId,
-  logs,
-  debug,
-  testOpts,
-}) {
-  try {
-    await api.createPluginRun({
-      deploy_id: deployId,
-      body: {
-        package: packageName,
-        version,
-        state,
-        reporting_event: event,
-        title,
-        summary,
-        text,
-        extra_data: extraData,
-      },
-    })
-    // Bitballoon API randomly fails with 502.
-    // Builds should be successful when this API call fails, but we still want
-    // to report the error both in logs and in error monitoring.
-  } catch (error) {
-    await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
-  }
-}

package/src/status/success.js

@@ -1,18 +0,0 @@
-import { runsOnlyOnBuildFailure } from '../plugins/events.js'
-
-// The last event handler of a plugin (except for `onError` and `onEnd`)
-// defaults to `utils.status.show({ state: 'success' })` without any `summary`.
-export const getSuccessStatus = function (newStatus, { steps, event, packageName }) {
-  if (newStatus === undefined && isLastNonErrorStep({ steps, event, packageName })) {
-    return IMPLICIT_STATUS
-  }
-
-  return newStatus
-}
-
-const isLastNonErrorStep = function ({ steps, event, packageName }) {
-  const nonErrorSteps = steps.filter((step) => step.packageName === packageName && !runsOnlyOnBuildFailure(step.event))
-  return nonErrorSteps.length === 0 || nonErrorSteps[nonErrorSteps.length - 1].event === event
-}
-
-const IMPLICIT_STATUS = { state: 'success', implicit: true }

package/src/steps/core_step.js

@@ -1,92 +0,0 @@
-import { setEnvChanges } from '../env/changes.js'
-import { addErrorInfo, isBuildError } from '../error/info.js'
-
-import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js'
-
-// Fire a core step
-export const fireCoreStep = async function ({
-  coreStep,
-  coreStepName,
-  configPath,
-  buildDir,
-  repositoryRoot,
-  constants,
-  buildbotServerSocket,
-  events,
-  logs,
-  nodePath,
-  childEnv,
-  context,
-  branch,
-  envChanges,
-  errorParams,
-  configOpts,
-  netlifyConfig,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  featureFlags,
-  debug,
-  systemLog,
-  saveConfig,
-}) {
-  try {
-    const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath])
-    const childEnvA = setEnvChanges(envChanges, { ...childEnv })
-    const {
-      newEnvChanges = {},
-      configMutations: newConfigMutations = [],
-      tags,
-    } = await coreStep({
-      configPath,
-      buildDir,
-      repositoryRoot,
-      constants,
-      buildbotServerSocket,
-      events,
-      logs,
-      context,
-      branch,
-      childEnv: childEnvA,
-      netlifyConfig,
-      nodePath,
-      configMutations,
-      headersPath,
-      redirectsPath,
-      featureFlags,
-      debug,
-      systemLog,
-      saveConfig,
-    })
-    const {
-      netlifyConfig: netlifyConfigA,
-      configMutations: configMutationsA,
-      headersPath: headersPathA,
-      redirectsPath: redirectsPathA,
-    } = await updateNetlifyConfig({
-      configOpts,
-      netlifyConfig,
-      headersPath,
-      redirectsPath,
-      configMutations,
-      newConfigMutations,
-      configSideFiles,
-      errorParams,
-      logs,
-      debug,
-    })
-    return {
-      newEnvChanges,
-      netlifyConfig: netlifyConfigA,
-      configMutations: configMutationsA,
-      headersPath: headersPathA,
-      redirectsPath: redirectsPathA,
-      tags,
-    }
-  } catch (newError) {
-    if (!isBuildError(newError)) {
-      addErrorInfo(newError, { type: 'coreStep', location: { coreStepName } })
-    }
-    return { newError }
-  }
-}

package/src/steps/error.js

@@ -1,102 +0,0 @@
-import { cancelBuild } from '../error/cancel.js'
-import { handleBuildError } from '../error/handle.js'
-import { getFullErrorInfo, parseErrorInfo } from '../error/parse/parse.js'
-import { serializeErrorStatus } from '../error/parse/serialize_status.js'
-import { isSoftFailEvent } from '../plugins/events.js'
-
-// Handle build command errors and plugin errors:
-//  - usually, propagate the error to make the build stop.
-//  - `utils.build.cancelBuild()` also cancels the build by calling the API
-//  - `utils.build.failPlugin()` or post-deploy errors do not make the build
-//    stop, but are still reported, and prevent future events from the same
-//    plugin.
-// This also computes error statuses that are sent to the API.
-export const handleStepError = function ({
-  event,
-  newError,
-  childEnv,
-  mode,
-  api,
-  errorMonitor,
-  deployId,
-  coreStep,
-  netlifyConfig,
-  logs,
-  debug,
-  testOpts,
-}) {
-  // Core steps do not report error statuses
-  if (coreStep !== undefined) {
-    return { newError }
-  }
-
-  const fullErrorInfo = getFullErrorInfo({ error: newError, colors: false, debug })
-  const { type } = fullErrorInfo
-
-  if (type === 'failPlugin' || isSoftFailEvent(event)) {
-    return handleFailPlugin({
-      fullErrorInfo,
-      newError,
-      childEnv,
-      mode,
-      errorMonitor,
-      netlifyConfig,
-      logs,
-      debug,
-      testOpts,
-    })
-  }
-
-  if (type === 'cancelBuild') {
-    return handleCancelBuild({ fullErrorInfo, newError, api, deployId })
-  }
-
-  return handleFailBuild({ fullErrorInfo, newError })
-}
-
-// On `utils.build.failPlugin()` or during `onSuccess` or `onEnd`
-const handleFailPlugin = async function ({
-  fullErrorInfo,
-  fullErrorInfo: {
-    errorInfo: { location: { packageName } = {} },
-  },
-  newError,
-  childEnv,
-  mode,
-  errorMonitor,
-  netlifyConfig,
-  logs,
-  debug,
-  testOpts,
-}) {
-  const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_plugin' })
-  await handleBuildError(newError, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
-  return { failedPlugin: [packageName], newStatus }
-}
-
-// On `utils.build.cancelBuild()`
-const handleCancelBuild = async function ({ fullErrorInfo, newError, api, deployId }) {
-  const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'canceled_build' })
-  await cancelBuild({ api, deployId })
-  return { newError, newStatus }
-}
-
-// On `utils.build.failBuild()` or uncaught exception
-const handleFailBuild = function ({ fullErrorInfo, newError }) {
-  const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' })
-  return { newError, newStatus }
-}
-
-// Unlike community plugins, core plugin bugs should be handled as system errors
-export const getPluginErrorType = function (error, loadedFrom) {
-  if (!isCorePluginBug(error, loadedFrom)) {
-    return {}
-  }
-
-  return { type: 'corePlugin' }
-}
-
-const isCorePluginBug = function (error, loadedFrom) {
-  const { severity } = parseErrorInfo(error)
-  return severity === 'warning' && loadedFrom === 'core'
-}

package/src/steps/get.js

@@ -1,51 +0,0 @@
-import { DEV_EVENTS, EVENTS } from '../plugins/events.js'
-import { buildCommandCore } from '../plugins_core/build_command.js'
-import { deploySite } from '../plugins_core/deploy/index.js'
-import { bundleEdgeFunctions } from '../plugins_core/edge_functions/index.js'
-import { bundleFunctions } from '../plugins_core/functions/index.js'
-
-// Get all build steps
-export const getSteps = function (steps) {
-  const stepsA = addCoreSteps(steps)
-  const stepsB = sortSteps(stepsA, EVENTS)
-  const events = getEvents(stepsB)
-  return { steps: stepsB, events }
-}
-
-// Get all dev steps
-export const getDevSteps = function (command, steps) {
-  const devCommandStep = {
-    event: 'onDev',
-    coreStep: async () => {
-      await command()
-
-      return {}
-    },
-    coreStepId: 'dev_command',
-    coreStepName: 'dev.command',
-    coreStepDescription: () => 'Run command for local development',
-  }
-  const sortedSteps = sortSteps([...steps, devCommandStep], DEV_EVENTS)
-  const events = getEvents(sortedSteps)
-
-  return { steps: sortedSteps, events }
-}
-
-const addCoreSteps = function (steps) {
-  return [buildCommandCore, ...steps, bundleFunctions, bundleEdgeFunctions, deploySite]
-}
-
-// Sort plugin steps by event order.
-const sortSteps = function (steps, events) {
-  return events.flatMap((event) => steps.filter((step) => step.event === event))
-}
-
-// Retrieve list of unique events
-const getEvents = function (steps) {
-  const events = steps.map(getEvent)
-  return [...new Set(events)]
-}
-
-const getEvent = function ({ event }) {
-  return event
-}

package/src/steps/plugin.js

@@ -1,85 +0,0 @@
-import { addErrorInfo } from '../error/info.js'
-import { logStepCompleted } from '../log/messages/ipc.js'
-import { pipePluginOutput, unpipePluginOutput } from '../log/stream.js'
-import { callChild } from '../plugins/ipc.js'
-import { getSuccessStatus } from '../status/success.js'
-
-import { getPluginErrorType } from './error.js'
-import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js'
-
-// Fire a plugin step
-export const firePluginStep = async function ({
-  event,
-  childProcess,
-  packageName,
-  pluginPackageJson,
-  loadedFrom,
-  origin,
-  envChanges,
-  errorParams,
-  configOpts,
-  netlifyConfig,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  constants,
-  steps,
-  error,
-  logs,
-  debug,
-  verbose,
-}) {
-  const listeners = pipePluginOutput(childProcess, logs)
-
-  try {
-    const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath])
-    const {
-      newEnvChanges,
-      configMutations: newConfigMutations,
-      status,
-    } = await callChild({
-      childProcess,
-      eventName: 'run',
-      payload: { event, error, envChanges, netlifyConfig, constants },
-      logs,
-      verbose,
-    })
-    const {
-      netlifyConfig: netlifyConfigA,
-      configMutations: configMutationsA,
-      headersPath: headersPathA,
-      redirectsPath: redirectsPathA,
-    } = await updateNetlifyConfig({
-      configOpts,
-      netlifyConfig,
-      headersPath,
-      redirectsPath,
-      configMutations,
-      newConfigMutations,
-      configSideFiles,
-      errorParams,
-      logs,
-      debug,
-    })
-    const newStatus = getSuccessStatus(status, { steps, event, packageName })
-    return {
-      newEnvChanges,
-      netlifyConfig: netlifyConfigA,
-      configMutations: configMutationsA,
-      headersPath: headersPathA,
-      redirectsPath: redirectsPathA,
-      newStatus,
-    }
-  } catch (newError) {
-    const errorType = getPluginErrorType(newError, loadedFrom)
-    addErrorInfo(newError, {
-      ...errorType,
-      plugin: { pluginPackageJson, packageName },
-      location: { event, packageName, loadedFrom, origin },
-    })
-    return { newError }
-  } finally {
-    await unpipePluginOutput(childProcess, logs, listeners)
-    logStepCompleted(logs, verbose)
-  }
-}

package/src/steps/return.js

@@ -1,52 +0,0 @@
-import { logTimer } from '../log/messages/core.js'
-import { logStepSuccess } from '../log/messages/steps.js'
-
-import { handleStepError } from './error.js'
-
-// Retrieve the return value of a step
-export const getStepReturn = function ({
-  event,
-  packageName,
-  newError,
-  newEnvChanges,
-  newStatus,
-  coreStep,
-  coreStepName: timerName = `${packageName} ${event}`,
-  childEnv,
-  mode,
-  api,
-  errorMonitor,
-  deployId,
-  netlifyConfig,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  logs,
-  debug,
-  timers,
-  durationNs,
-  testOpts,
-}) {
-  if (newError !== undefined) {
-    return handleStepError({
-      event,
-      newError,
-      childEnv,
-      mode,
-      api,
-      errorMonitor,
-      deployId,
-      coreStep,
-      netlifyConfig,
-      logs,
-      debug,
-      testOpts,
-    })
-  }
-
-  logStepSuccess(logs)
-
-  logTimer(logs, durationNs, timerName)
-
-  return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers }
-}