@netlify/build 28.0.0-beta → 28.0.0

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,32 +0,0 @@
-import { 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)
-  const events = getEvents(stepsB)
-  return { steps: stepsB, events }
-}
-
-const addCoreSteps = function (steps) {
-  return [buildCommandCore, ...steps, bundleFunctions, bundleEdgeFunctions, deploySite]
-}
-
-// Sort plugin steps by event order.
-const sortSteps = function (steps) {
-  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 }
-}

package/src/steps/run_core_steps.js

@@ -1,194 +0,0 @@
-import { getConfigOpts, loadConfig } from '../core/config.js'
-import { getConstants } from '../core/constants.js'
-import { normalizeFlags } from '../core/normalize_flags.js'
-import { getSeverity } from '../core/severity.js'
-import { handleBuildError } from '../error/handle.js'
-import { getErrorInfo } from '../error/info.js'
-import { startErrorMonitor } from '../error/monitor/start.js'
-import { getBufferLogs } from '../log/logger.js'
-import { logBuildStart } from '../log/messages/core.js'
-import { reportStatuses } from '../status/report.js'
-
-import { getSteps } from './get.js'
-import { runSteps } from './run_steps.js'
-
-/**
- * Runs specific core steps for a build and returns whether it succeeded or not.
- *
- * @param  {string[]} [buildSteps] - a string array of build steps to run
- * @param  {object} [flags] - build configuration CLI flags
- * @param  {string} [flags.config] - Path to the configuration file
- * @param  {string} [flags.cwd] - Current directory. Used to retrieve the configuration file
- * @param  {string} [flags.repositoryRoot] - Git repository root directory. Used to retrieve the configuration file.
- * @param  {string} [flags.apiHost] - Netlify API endpoint
- * @param  {string} [flags.token] - Netlify API token for authentication
- * @param  {string} [flags.siteId] - Netlify Site ID
- * @param  {string} [flags.deployId] - Netlify Deploy ID
- * @param  {string} [flags.context] - Build context
- * @param  {string} [flags.branch] - Repository branch
- * @param  {boolean} [flags.dry=false] - Run in dry mode, i.e. printing steps without executing them
- * @param  {string} [flags.nodePath] - Path to the Node.js binary to use in the build command and plugins
- * @param  {boolean} [flags.buffer=false] - Buffer output instead of printing it
- *
- * @returns {object} buildResult
- * @returns {boolean} buildResult.success - Whether build succeeded or failed
- * @returns {number} buildResult.severityCode - Build success/failure status among:
- * 0 (success), 1 (build cancelled), 2 (user error), 3 (plugin error), 4 (system error). Can be used as exit code.
- * @returns {string[]} buildResult.logs - When using the `buffer` option, all log messages
- */
-export const runCoreSteps = async (buildSteps, flags = {}) => {
-  const { errorMonitor, mode, logs, debug, ...flagsA } = startBuild(flags)
-  const errorParams = { errorMonitor, mode, logs, debug }
-
-  try {
-    const { netlifyConfig: netlifyConfigA, configMutations } = await executeBuildStep({
-      ...flagsA,
-      errorMonitor,
-      mode,
-      logs,
-      debug,
-      errorParams,
-      buildSteps,
-    })
-    const { success, severityCode } = getSeverity('success')
-
-    return { success, severityCode, netlifyConfig: netlifyConfigA, configMutations, logs }
-  } catch (error) {
-    const { severity } = await handleBuildError(error, errorParams)
-    const { success, severityCode } = getSeverity(severity)
-
-    return { success, severityCode, logs }
-  }
-}
-
-const startBuild = function (flags) {
-  const logs = getBufferLogs(flags)
-
-  logBuildStart(logs)
-
-  const { bugsnagKey, ...flagsA } = normalizeFlags(flags, logs)
-  const errorMonitor = startErrorMonitor({ flags: flagsA, logs, bugsnagKey })
-
-  return { ...flagsA, errorMonitor, logs }
-}
-
-const getBuildSteps = function (buildSteps) {
-  const allSteps = getSteps([]).steps.filter(({ coreStepId }) => buildSteps.includes(coreStepId))
-
-  return allSteps
-}
-
-const executeBuildStep = async function ({
-  config,
-  defaultConfig,
-  cachedConfig,
-  debug,
-  nodePath,
-  functionsDistDir,
-  edgeFunctionsDistDir,
-  errorMonitor,
-  mode,
-  logs,
-  errorParams,
-  featureFlags,
-  buildSteps,
-  repositoryRoot,
-}) {
-  const configOpts = getConfigOpts({
-    config,
-    defaultConfig,
-    featureFlags,
-    mode,
-    repositoryRoot,
-  })
-  const {
-    netlifyConfig,
-    buildDir,
-    siteInfo,
-    childEnv,
-    userNodeVersion,
-    repositoryRoot: repositoryRootA,
-  } = await loadConfig({
-    configOpts,
-    cachedConfig,
-    debug,
-    logs,
-    nodePath,
-    timers: [],
-  })
-  const constants = await getConstants({
-    buildDir,
-    functionsDistDir,
-    edgeFunctionsDistDir,
-    netlifyConfig,
-    siteInfo,
-    mode,
-  })
-
-  // eslint-disable-next-line fp/no-mutating-assign
-  Object.assign(errorParams, { netlifyConfig, siteInfo, childEnv, userNodeVersion })
-
-  try {
-    const { netlifyConfig: netlifyConfigA, configMutations } = await runBuildStep({
-      netlifyConfig,
-      buildDir,
-      nodePath,
-      logs,
-      debug,
-      constants,
-      featureFlags,
-      childEnv,
-      buildSteps,
-      repositoryRoot: repositoryRootA,
-    })
-
-    return {
-      netlifyConfig: netlifyConfigA,
-      configMutations,
-    }
-  } catch (error) {
-    const [{ statuses }] = getErrorInfo(error)
-
-    await reportStatuses({
-      statuses,
-      childEnv,
-      mode,
-      netlifyConfig,
-      errorMonitor,
-      logs,
-      debug,
-      pluginsOptions: [],
-    })
-
-    throw error
-  }
-}
-
-const runBuildStep = async function ({
-  netlifyConfig,
-  buildDir,
-  nodePath,
-  constants,
-  logs,
-  debug,
-  featureFlags,
-  childEnv,
-  buildSteps,
-  repositoryRoot,
-}) {
-  const { netlifyConfig: netlifyConfigA, configMutations } = await runSteps({
-    steps: getBuildSteps(buildSteps),
-    buildDir,
-    nodePath,
-    constants,
-    netlifyConfig,
-    logs,
-    debug,
-    timers: [],
-    featureFlags,
-    childEnv,
-    repositoryRoot,
-  })
-
-  return { netlifyConfig: netlifyConfigA, configMutations }
-}