@netlify/build 18.13.11 → 18.15.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@netlify/build",
-  "version": "18.13.11",
+  "version": "18.15.0",
   "description": "Netlify build module",
   "main": "src/core/main.js",
+  "types": "types/index.d.ts",
   "bin": {
     "netlify-build": "./src/core/bin.js"
   },
@@ -59,7 +60,7 @@
     "@netlify/plugin-edge-handlers": "^1.11.22",
     "@netlify/plugins-list": "^4.0.0",
     "@netlify/run-utils": "^2.0.0",
-    "@netlify/zip-it-and-ship-it": "^4.23.6",
+    "@netlify/zip-it-and-ship-it": "^4.24.0",
     "@sindresorhus/slugify": "^1.1.0",
     "@ungap/from-entries": "^0.2.1",
     "ansi-escapes": "^4.3.2",

package/src/core/config.js

@@ -123,7 +123,7 @@ const logConfigInfo = function ({ logs, configPath, buildDir, netlifyConfig, con
 // normalized.
 // We use `debug: false` to avoid any debug logs. Otherwise every configuration
 // change would create debug logs which would be too verbose.
-// Errors are propagated and assigned to the specific plugin or core command
+// Errors are propagated and assigned to the specific plugin or core step
 // which changed the configuration.
 const resolveUpdatedConfig = async function (configOpts, configMutations) {
   try {

package/src/core/constants.js

@@ -52,7 +52,7 @@ const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal'
 
 // Retrieve constants which might change during the build if a plugin modifies
 // `netlifyConfig` or creates some default directories.
-// Unlike readonly constants, this is called again before each command.
+// Unlike readonly constants, this is called again before each build step.
 const addMutableConstants = async function ({
   constants,
   buildDir,

package/src/core/dry.js

@@ -2,27 +2,27 @@
 
 const pFilter = require('p-filter')
 
-const { logDryRunStart, logDryRunCommand, logDryRunEnd } = require('../log/messages/dry')
+const { logDryRunStart, logDryRunStep, logDryRunEnd } = require('../log/messages/dry')
 const { runsOnlyOnBuildFailure } = require('../plugins/events')
 
 // If the `dry` flag is specified, do a dry run
-const doDryRun = async function ({ buildDir, commands, netlifyConfig, constants, buildbotServerSocket, logs }) {
-  const successCommands = await pFilter(commands, ({ event, condition }) =>
-    shouldIncludeCommand({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }),
+const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }) {
+  const successSteps = await pFilter(steps, ({ event, condition }) =>
+    shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }),
   )
-  const eventWidth = Math.max(...successCommands.map(getEventLength))
-  const commandsCount = successCommands.length
+  const eventWidth = Math.max(...successSteps.map(getEventLength))
+  const stepsCount = successSteps.length
 
-  logDryRunStart({ logs, eventWidth, commandsCount })
+  logDryRunStart({ logs, eventWidth, stepsCount })
 
-  successCommands.forEach((command, index) => {
-    logDryRunCommand({ logs, command, index, netlifyConfig, eventWidth, commandsCount })
+  successSteps.forEach((step, index) => {
+    logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount })
   })
 
   logDryRunEnd(logs)
 }
 
-const shouldIncludeCommand = async function ({
+const shouldIncludeStep = async function ({
   buildDir,
   event,
   condition,

package/src/core/feature_flags.js

@@ -15,6 +15,7 @@ const getFeatureFlag = function (name) {
 
 // Default values for feature flags
 const DEFAULT_FEATURE_FLAGS = {
+  buildbot_build_go_functions: false,
   buildbot_es_modules_esbuild: false,
   buildbot_zisi_esbuild_parser: false,
   netlify_config_toml_backslash: false,

package/src/core/flags.js

@@ -94,12 +94,12 @@ Default: true`,
   dry: {
     alias: 'dry-run',
     boolean: true,
-    describe: `Run in dry mode, i.e. printing commands without executing them.
+    describe: `Run in dry mode, i.e. printing steps without executing them.
 Default: false`,
   },
   nodePath: {
     string: true,
-    describe: `Path to the Node.js binary to use in user commands and build plugins.
+    describe: `Path to the Node.js binary to use in the build command and plugins.
 Default: Current Node.js binary`,
   },
   functionsDistDir: {

package/src/core/main.js

@@ -3,8 +3,6 @@
 /* eslint-disable max-lines, import/max-dependencies */
 require('../utils/polyfills')
 
-const { getCommands } = require('../commands/get')
-const { runCommands } = require('../commands/run_commands')
 const { handleBuildError } = require('../error/handle')
 const { getErrorInfo } = require('../error/info')
 const { startErrorMonitor } = require('../error/monitor/start')
@@ -16,6 +14,8 @@ const { pinPlugins } = require('../plugins/pinned_version')
 const { startPlugins, stopPlugins } = require('../plugins/spawn')
 const { addCorePlugins } = require('../plugins_core/add')
 const { reportStatuses } = require('../status/report')
+const { getSteps } = require('../steps/get')
+const { runSteps } = require('../steps/run_steps')
 const { trackBuildComplete } = require('../telemetry/main')
 const { initTimers, measureDuration } = require('../time/main')
 const { reportTimers } = require('../time/report')
@@ -42,8 +42,8 @@ const { getSeverity } = require('./severity')
  * @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 commands without executing them
- * @param  {string} [flags.nodePath] - Path to the Node.js binary to use in user commands and build plugins
+ * @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
@@ -75,7 +75,7 @@ const build = async function (flags = {}) {
       netlifyConfig: netlifyConfigA,
       siteInfo,
       userNodeVersion,
-      commandsCount,
+      stepsCount,
       timers,
       durationNs,
       configMutations,
@@ -104,7 +104,7 @@ const build = async function (flags = {}) {
       buildId,
       deployId,
       status,
-      commandsCount,
+      stepsCount,
       pluginsOptions,
       durationNs,
       siteInfo,
@@ -248,7 +248,7 @@ const tExecBuild = async function ({
   const {
     pluginsOptions: pluginsOptionsA,
     netlifyConfig: netlifyConfigA,
-    commandsCount,
+    stepsCount,
     timers: timersB,
     configMutations,
   } = await runAndReportBuild({
@@ -288,7 +288,7 @@ const tExecBuild = async function ({
     netlifyConfig: netlifyConfigA,
     siteInfo,
     userNodeVersion,
-    commandsCount,
+    stepsCount,
     timers: timersB,
     configMutations,
   }
@@ -331,7 +331,7 @@ const runAndReportBuild = async function ({
 }) {
   try {
     const {
-      commandsCount,
+      stepsCount,
       netlifyConfig: netlifyConfigA,
       statuses,
       pluginsOptions: pluginsOptionsA,
@@ -404,7 +404,7 @@ const runAndReportBuild = async function ({
     return {
       pluginsOptions: pluginsOptionsA,
       netlifyConfig: netlifyConfigA,
-      commandsCount,
+      stepsCount,
       timers: timersA,
       configMutations,
     }
@@ -492,7 +492,7 @@ const initAndRunBuild = async function ({
 
   try {
     const {
-      commandsCount,
+      stepsCount,
       netlifyConfig: netlifyConfigA,
       statuses,
       failedPlugins,
@@ -535,7 +535,7 @@ const initAndRunBuild = async function ({
     ])
 
     return {
-      commandsCount,
+      stepsCount,
       netlifyConfig: netlifyConfigA,
       statuses,
       pluginsOptions: pluginsOptionsA,
@@ -580,7 +580,7 @@ const runBuild = async function ({
   testOpts,
   featureFlags,
 }) {
-  const { pluginsCommands, timers: timersA } = await loadPlugins({
+  const { pluginsSteps, timers: timersA } = await loadPlugins({
     pluginsOptions,
     childProcesses,
     packageJson,
@@ -588,22 +588,22 @@ const runBuild = async function ({
     debug,
   })
 
-  const { commands, events } = getCommands(pluginsCommands)
+  const { steps, events } = getSteps(pluginsSteps)
 
   if (dry) {
-    await doDryRun({ buildDir, commands, netlifyConfig, constants, buildbotServerSocket, logs })
+    await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs })
     return { netlifyConfig }
   }
 
   const {
-    commandsCount,
+    stepsCount,
     netlifyConfig: netlifyConfigA,
     statuses,
     failedPlugins,
     timers: timersB,
     configMutations,
-  } = await runCommands({
-    commands,
+  } = await runSteps({
+    steps,
     buildbotServerSocket,
     events,
     configPath,
@@ -631,7 +631,7 @@ const runBuild = async function ({
     featureFlags,
   })
 
-  return { commandsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations }
+  return { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations }
 }
 
 // Logs and reports that a build successfully ended
@@ -651,7 +651,7 @@ const telemetryReport = async function ({
   deployId,
   buildId,
   status,
-  commandsCount,
+  stepsCount,
   pluginsOptions,
   durationNs,
   siteInfo,
@@ -666,7 +666,7 @@ const telemetryReport = async function ({
       deployId,
       buildId,
       status,
-      commandsCount,
+      stepsCount,
       pluginsOptions,
       durationNs,
       siteInfo,

package/src/error/parse/location.js

@@ -29,8 +29,8 @@ const getFunctionsBundlingLocation = function ({ functionName }) {
   return `While bundling Function "${functionName}"`
 }
 
-const getCoreCommandLocation = function ({ coreCommandName }) {
-  return `During ${coreCommandName}`
+const getCoreStepLocation = function ({ coreStepName }) {
+  return `During ${coreStepName}`
 }
 
 const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
@@ -54,7 +54,7 @@ const getApiLocation = function ({ endpoint, parameters }) {
 const LOCATIONS = {
   buildCommand: getBuildCommandLocation,
   functionsBundling: getFunctionsBundlingLocation,
-  coreCommand: getCoreCommandLocation,
+  coreStep: getCoreStepLocation,
   buildFail: getBuildFailLocation,
   api: getApiLocation,
 }

package/src/error/type.js

@@ -141,13 +141,13 @@ const TYPES = {
     severity: 'error',
   },
 
-  // Core command internal error
-  coreCommand: {
-    title: ({ location: { coreCommandName } }) => `Internal error during "${coreCommandName}"`,
+  // Core step internal error
+  coreStep: {
+    title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
     stackType: 'stack',
     showErrorProps: true,
     rawStack: true,
-    locationType: 'coreCommand',
+    locationType: 'coreStep',
     severity: 'error',
   },
 

package/src/log/messages/dry.js

@@ -5,8 +5,8 @@ const { arrowDown } = require('figures')
 const { logMessage, logSubHeader } = require('../logger')
 const { THEME } = require('../theme')
 
-const logDryRunStart = function ({ logs, eventWidth, commandsCount }) {
-  const columnWidth = getDryColumnWidth(eventWidth, commandsCount)
+const logDryRunStart = function ({ logs, eventWidth, stepsCount }) {
+  const columnWidth = getDryColumnWidth(eventWidth, stepsCount)
   const line = '─'.repeat(columnWidth)
   const secondLine = '─'.repeat(columnWidth)
 
@@ -23,19 +23,19 @@ ${THEME.header(`┌─${line}─┬─${secondLine}─┐
   )
 }
 
-const logDryRunCommand = function ({
+const logDryRunStep = function ({
   logs,
-  command: { event, packageName, coreCommandDescription },
+  step: { event, packageName, coreStepDescription },
   index,
   netlifyConfig,
   eventWidth,
-  commandsCount,
+  stepsCount,
 }) {
-  const columnWidth = getDryColumnWidth(eventWidth, commandsCount)
-  const fullName = getFullName(coreCommandDescription, netlifyConfig, packageName)
+  const columnWidth = getDryColumnWidth(eventWidth, stepsCount)
+  const fullName = getFullName(coreStepDescription, netlifyConfig, packageName)
   const line = '─'.repeat(columnWidth)
   const countText = `${index + 1}. `
-  const downArrow = commandsCount === index + 1 ? '  ' : ` ${arrowDown}`
+  const downArrow = stepsCount === index + 1 ? '  ' : ` ${arrowDown}`
   const eventWidthA = columnWidth - countText.length - downArrow.length
 
   logMessage(
@@ -46,14 +46,14 @@ ${THEME.header(`└─${line}─┘ `)}`,
   )
 }
 
-const getFullName = function (coreCommandDescription, netlifyConfig, packageName) {
-  return coreCommandDescription === undefined
+const getFullName = function (coreStepDescription, netlifyConfig, packageName) {
+  return coreStepDescription === undefined
     ? `Plugin ${THEME.highlightWords(packageName)}`
-    : coreCommandDescription({ netlifyConfig })
+    : coreStepDescription({ netlifyConfig })
 }
 
-const getDryColumnWidth = function (eventWidth, commandsCount) {
-  const symbolsWidth = `${commandsCount}`.length + COLUMN_EXTRA_WIDTH
+const getDryColumnWidth = function (eventWidth, stepsCount) {
+  const symbolsWidth = `${stepsCount}`.length + COLUMN_EXTRA_WIDTH
   return Math.max(eventWidth + symbolsWidth, DRY_HEADER_NAMES[1].length)
 }
 
@@ -66,6 +66,6 @@ const logDryRunEnd = function (logs) {
 
 module.exports = {
   logDryRunStart,
-  logDryRunCommand,
+  logDryRunStep,
   logDryRunEnd,
 }

package/src/log/messages/steps.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { getLogHeaderFunc } = require('../header_func')
+const { log, logMessage } = require('../logger')
+const { THEME } = require('../theme')
+
+const logStepStart = function ({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig }) {
+  const description = getDescription({ coreStepDescription, netlifyConfig, packageName, event })
+  const logHeaderFunc = getLogHeaderFunc(error)
+  logHeaderFunc(logs, `${index + 1}. ${description}`)
+  logMessage(logs, '')
+}
+
+const getDescription = function ({ coreStepDescription, netlifyConfig, packageName, event }) {
+  return coreStepDescription === undefined
+    ? `${event} step from ${packageName}`
+    : coreStepDescription({ netlifyConfig })
+}
+
+const logBuildCommandStart = function (logs, buildCommand) {
+  log(logs, THEME.highlightWords(`$ ${buildCommand}`))
+}
+
+const logStepSuccess = function (logs) {
+  logMessage(logs, '')
+}
+
+module.exports = {
+  logStepStart,
+  logBuildCommandStart,
+  logStepSuccess,
+}

package/src/log/stream.js

@@ -36,7 +36,7 @@ const pushBuildCommandOutput = function (output, logsArray) {
   logsArray.push(output)
 }
 
-// Start plugin command output
+// Start plugin step output
 const pipePluginOutput = function (childProcess, logs) {
   if (logs === undefined) {
     return streamOutput(childProcess)
@@ -45,7 +45,7 @@ const pipePluginOutput = function (childProcess, logs) {
   return pushOutputToLogs(childProcess, logs)
 }
 
-// Stop streaming/buffering plugin command output
+// Stop streaming/buffering plugin step output
 const unpipePluginOutput = async function (childProcess, logs, listeners) {
   // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
   await pSetTimeout(0)

package/src/plugins/child/load.js

@@ -7,21 +7,21 @@ const { validatePlugin } = require('./validate')
 // This also requires the plugin file and fire its top-level function.
 // This also validates the plugin.
 // Do it when parent requests it using the `load` event.
-// Also figure out the list of plugin commands. This is also passed to the parent.
+// Also figure out the list of plugin steps. This is also passed to the parent.
 const load = function ({ pluginPath, inputs, packageJson }) {
   const logic = getLogic({ pluginPath, inputs })
 
   validatePlugin(logic)
 
-  const pluginCommands = getPluginCommands(logic)
+  const pluginSteps = getPluginSteps(logic)
 
   // Context passed to every event handler
-  const context = { pluginCommands, inputs, packageJson }
+  const context = { pluginSteps, inputs, packageJson }
 
-  return { pluginCommands, context }
+  return { pluginSteps, context }
 }
 
-const getPluginCommands = function (logic) {
+const getPluginSteps = function (logic) {
   return Object.entries(logic)
     .filter(isEventHandler)
     .map(([event, method]) => ({ event, method }))

package/src/plugins/child/run.js

@@ -8,9 +8,9 @@ const { getUtils } = require('./utils')
 // Run a specific plugin event handler
 const run = async function (
   { event, error, constants, envChanges, netlifyConfig },
-  { pluginCommands, inputs, packageJson },
+  { pluginSteps, inputs, packageJson },
 ) {
-  const { method } = pluginCommands.find((pluginCommand) => pluginCommand.event === event)
+  const { method } = pluginSteps.find((pluginStep) => pluginStep.event === event)
   const runState = {}
   const utils = getUtils({ event, constants, runState })
   const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig)

package/src/plugins/load.js

@@ -6,28 +6,28 @@ const { measureDuration } = require('../time/main')
 
 const { callChild } = require('./ipc')
 
-// Retrieve all plugins commands
+// Retrieve all plugins steps
 // Can use either a module name or a file path to the plugin.
 const loadPlugins = async function ({ pluginsOptions, childProcesses, packageJson, timers, debug }) {
   return pluginsOptions.length === 0
-    ? { pluginsCommands: [], timers }
+    ? { pluginsSteps: [], timers }
     : await loadAllPlugins({ pluginsOptions, childProcesses, packageJson, timers, debug })
 }
 
 const tLoadAllPlugins = async function ({ pluginsOptions, childProcesses, packageJson, debug }) {
-  const pluginsCommands = await Promise.all(
+  const pluginsSteps = await Promise.all(
     pluginsOptions.map((pluginOptions, index) =>
       loadPlugin(pluginOptions, { childProcesses, index, packageJson, debug }),
     ),
   )
-  const pluginsCommandsA = pluginsCommands.flat()
-  return { pluginsCommands: pluginsCommandsA }
+  const pluginsStepsA = pluginsSteps.flat()
+  return { pluginsSteps: pluginsStepsA }
 }
 
 // Only performed if there are some plugins
 const loadAllPlugins = measureDuration(tLoadAllPlugins, 'load_plugins')
 
-// Retrieve plugin commands for one plugin.
+// Retrieve plugin steps for one plugin.
 // Do it by executing the plugin `load` event handler.
 const loadPlugin = async function (
   { packageName, pluginPackageJson, pluginPackageJson: { version } = {}, pluginPath, inputs, loadedFrom, origin },
@@ -37,8 +37,8 @@ const loadPlugin = async function (
   const loadEvent = 'load'
 
   try {
-    const { pluginCommands } = await callChild(childProcess, 'load', { pluginPath, inputs, packageJson })
-    const pluginCommandsA = pluginCommands.map(({ event }) => ({
+    const { pluginSteps } = await callChild(childProcess, 'load', { pluginPath, inputs, packageJson })
+    const pluginStepsA = pluginSteps.map(({ event }) => ({
       event,
       packageName,
       loadedFrom,
@@ -46,7 +46,7 @@ const loadPlugin = async function (
       pluginPackageJson,
       childProcess,
     }))
-    return pluginCommandsA
+    return pluginStepsA
   } catch (error) {
     addErrorInfo(error, {
       plugin: { packageName, pluginPackageJson },

package/src/plugins_core/build_command.js

@@ -6,11 +6,11 @@ const execa = require('execa')
 
 const { addErrorInfo } = require('../error/info')
 const { getBuildCommandDescription } = require('../log/description')
-const { logBuildCommandStart } = require('../log/messages/commands')
+const { logBuildCommandStart } = require('../log/messages/steps')
 const { getBuildCommandStdio, handleBuildCommandOutput } = require('../log/stream')
 
 // Fire `build.command`
-const coreCommand = async function ({
+const coreStep = async function ({
   configPath,
   buildDir,
   nodePath,
@@ -51,7 +51,7 @@ const coreCommand = async function ({
 // We use Bash on Unix and `cmd.exe` on Windows
 const SHELL = platform === 'win32' ? true : 'bash'
 
-const coreCommandDescription = function ({
+const coreStepDescription = function ({
   netlifyConfig: {
     build: { commandOrigin: buildCommandOrigin },
   },
@@ -69,10 +69,10 @@ const hasBuildCommand = function ({
 
 const buildCommandCore = {
   event: 'onBuild',
-  coreCommand,
-  coreCommandId: 'build_command',
-  coreCommandName: 'build.command',
-  coreCommandDescription,
+  coreStep,
+  coreStepId: 'build_command',
+  coreStepName: 'build.command',
+  coreStepDescription,
   condition: hasBuildCommand,
 }
 

package/src/plugins_core/deploy/buildbot_client.js

@@ -88,9 +88,7 @@ const getDeployDir = function ({ buildDir, repositoryRoot, constants: { PUBLISH_
 const handleDeployError = function (error, errorType) {
   const errorA = new Error(`Deploy did not succeed: ${error}`)
   const errorInfo =
-    errorType === 'user'
-      ? { type: 'resolveConfig' }
-      : { type: 'coreCommand', location: { coreCommandName: 'Deploy site' } }
+    errorType === 'user' ? { type: 'resolveConfig' } : { type: 'coreStep', location: { coreStepName: 'Deploy site' } }
   addErrorInfo(errorA, errorInfo)
   throw errorA
 }

package/src/plugins_core/deploy/index.js

@@ -10,7 +10,7 @@ const {
   deploySiteWithBuildbotClient,
 } = require('./buildbot_client')
 
-const coreCommand = async function ({
+const coreStep = async function ({
   buildDir,
   configPath,
   repositoryRoot,
@@ -67,10 +67,10 @@ const shouldDeploy = function ({ buildbotServerSocket }) {
 
 const deploySite = {
   event: 'onPostBuild',
-  coreCommand,
-  coreCommandId: 'deploy_site',
-  coreCommandName: 'Deploy site',
-  coreCommandDescription: () => 'Deploy site',
+  coreStep,
+  coreStepId: 'deploy_site',
+  coreStepName: 'Deploy site',
+  coreStepDescription: () => 'Deploy site',
   condition: shouldDeploy,
 }
 

package/src/plugins_core/functions/index.js

@@ -8,11 +8,7 @@ const mapObject = require('map-obj')
 const pathExists = require('path-exists')
 
 const { log } = require('../../log/logger')
-const {
-  logBundleResults,
-  logFunctionsNonExistingDir,
-  logFunctionsToBundle,
-} = require('../../log/messages/core_commands')
+const { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } = require('../../log/messages/core_steps')
 
 const { getZipError } = require('./error')
 const { getUserAndInternalFunctions, validateFunctionsSrc } = require('./utils')
@@ -52,6 +48,7 @@ const getZisiParameters = ({ buildDir, featureFlags, functionsConfig, functionsD
     normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally }),
   ])
   const zisiFeatureFlags = {
+    buildGoSource: featureFlags.buildbot_build_go_functions,
     defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
     parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
   }
@@ -89,7 +86,7 @@ const zipFunctionsAndLogResults = async ({
 
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
 // eslint-disable-next-line complexity
-const coreCommand = async function ({
+const coreStep = async function ({
   constants: {
     INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc,
     IS_LOCAL: isRunningLocally,
@@ -152,7 +149,7 @@ const coreCommand = async function ({
   }
 }
 
-// We run this core command if at least one of the functions directories (the
+// We run this core step if at least one of the functions directories (the
 // one configured by the user or the internal one) exists. We use a dynamic
 // `condition` because the directories might be created by the build command
 // or plugins.
@@ -170,10 +167,10 @@ const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNA
 
 const bundleFunctions = {
   event: 'onBuild',
-  coreCommand,
-  coreCommandId: 'functions_bundling',
-  coreCommandName: 'Functions bundling',
-  coreCommandDescription: () => 'Functions bundling',
+  coreStep,
+  coreStepId: 'functions_bundling',
+  coreStepName: 'Functions bundling',
+  coreStepDescription: () => 'Functions bundling',
   condition: hasFunctionsDirectories,
 }
 

package/src/status/success.js

@@ -4,19 +4,17 @@ const { runsOnlyOnBuildFailure } = require('../plugins/events')
 
 // The last event handler of a plugin (except for `onError` and `onEnd`)
 // defaults to `utils.status.show({ state: 'success' })` without any `summary`.
-const getSuccessStatus = function (newStatus, { commands, event, packageName }) {
-  if (newStatus === undefined && isLastNonErrorCommand({ commands, event, packageName })) {
+const getSuccessStatus = function (newStatus, { steps, event, packageName }) {
+  if (newStatus === undefined && isLastNonErrorStep({ steps, event, packageName })) {
     return IMPLICIT_STATUS
   }
 
   return newStatus
 }
 
-const isLastNonErrorCommand = function ({ commands, event, packageName }) {
-  const nonErrorCommands = commands.filter(
-    (command) => command.packageName === packageName && !runsOnlyOnBuildFailure(command.event),
-  )
-  return nonErrorCommands.length === 0 || nonErrorCommands[nonErrorCommands.length - 1].event === event
+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/{commands/core_command.js → steps/core_step.js}

@@ -5,10 +5,10 @@ const { addErrorInfo, isBuildError } = require('../error/info')
 
 const { updateNetlifyConfig, listConfigSideFiles } = require('./update_config')
 
-// Fire a core command
-const fireCoreCommand = async function ({
-  coreCommand,
-  coreCommandName,
+// Fire a core step
+const fireCoreStep = async function ({
+  coreStep,
+  coreStepName,
   configPath,
   buildDir,
   repositoryRoot,
@@ -38,7 +38,7 @@ const fireCoreCommand = async function ({
       newEnvChanges = {},
       configMutations: newConfigMutations = [],
       tags,
-    } = await coreCommand({
+    } = await coreStep({
       configPath,
       buildDir,
       repositoryRoot,
@@ -85,10 +85,10 @@ const fireCoreCommand = async function ({
     }
   } catch (newError) {
     if (!isBuildError(newError)) {
-      addErrorInfo(newError, { type: 'coreCommand', location: { coreCommandName } })
+      addErrorInfo(newError, { type: 'coreStep', location: { coreStepName } })
     }
     return { newError }
   }
 }
 
-module.exports = { fireCoreCommand }
+module.exports = { fireCoreStep }

package/src/{commands → steps}/error.js

@@ -13,7 +13,7 @@ const { isSoftFailEvent } = require('../plugins/events')
 //    stop, but are still reported, and prevent future events from the same
 //    plugin.
 // This also computes error statuses that are sent to the API.
-const handleCommandError = function ({
+const handleStepError = function ({
   event,
   newError,
   childEnv,
@@ -21,14 +21,14 @@ const handleCommandError = function ({
   api,
   errorMonitor,
   deployId,
-  coreCommand,
+  coreStep,
   netlifyConfig,
   logs,
   debug,
   testOpts,
 }) {
-  // Core commands do not report error statuses
-  if (coreCommand !== undefined) {
+  // Core steps do not report error statuses
+  if (coreStep !== undefined) {
     return { newError }
   }
 
@@ -103,4 +103,4 @@ const isCorePluginBug = function (error, loadedFrom) {
   return severity === 'warning' && loadedFrom === 'core'
 }
 
-module.exports = { handleCommandError, getPluginErrorType }
+module.exports = { handleStepError, getPluginErrorType }

package/src/steps/get.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { EVENTS } = require('../plugins/events')
+const { buildCommandCore } = require('../plugins_core/build_command')
+const { deploySite } = require('../plugins_core/deploy')
+const { bundleFunctions } = require('../plugins_core/functions')
+
+// Get all build steps
+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, 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
+}
+
+module.exports = { getSteps }

package/src/{commands → steps}/plugin.js

@@ -8,8 +8,8 @@ const { getSuccessStatus } = require('../status/success')
 const { getPluginErrorType } = require('./error')
 const { updateNetlifyConfig, listConfigSideFiles } = require('./update_config')
 
-// Fire a plugin command
-const firePluginCommand = async function ({
+// Fire a plugin step
+const firePluginStep = async function ({
   event,
   childProcess,
   packageName,
@@ -24,7 +24,7 @@ const firePluginCommand = async function ({
   headersPath,
   redirectsPath,
   constants,
-  commands,
+  steps,
   error,
   logs,
   debug,
@@ -61,7 +61,7 @@ const firePluginCommand = async function ({
       logs,
       debug,
     })
-    const newStatus = getSuccessStatus(status, { commands, event, packageName })
+    const newStatus = getSuccessStatus(status, { steps, event, packageName })
     return {
       newEnvChanges,
       netlifyConfig: netlifyConfigA,
@@ -83,4 +83,4 @@ const firePluginCommand = async function ({
   }
 }
 
-module.exports = { firePluginCommand }
+module.exports = { firePluginStep }

package/src/{commands → steps}/return.js

@@ -1,19 +1,19 @@
 'use strict'
 
-const { logCommandSuccess } = require('../log/messages/commands')
 const { logTimer } = require('../log/messages/core')
+const { logStepSuccess } = require('../log/messages/steps')
 
-const { handleCommandError } = require('./error')
+const { handleStepError } = require('./error')
 
-// Retrieve the return value of a build command or plugin event handler
-const getCommandReturn = function ({
+// Retrieve the return value of a step
+const getStepReturn = function ({
   event,
   packageName,
   newError,
   newEnvChanges,
   newStatus,
-  coreCommand,
-  coreCommandName: timerName = `${packageName} ${event}`,
+  coreStep,
+  coreStepName: timerName = `${packageName} ${event}`,
   childEnv,
   mode,
   api,
@@ -30,7 +30,7 @@ const getCommandReturn = function ({
   testOpts,
 }) {
   if (newError !== undefined) {
-    return handleCommandError({
+    return handleStepError({
       event,
       newError,
       childEnv,
@@ -38,7 +38,7 @@ const getCommandReturn = function ({
       api,
       errorMonitor,
       deployId,
-      coreCommand,
+      coreStep,
       netlifyConfig,
       logs,
       debug,
@@ -46,11 +46,11 @@ const getCommandReturn = function ({
     })
   }
 
-  logCommandSuccess(logs)
+  logStepSuccess(logs)
 
   logTimer(logs, durationNs, timerName)
 
   return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers }
 }
 
-module.exports = { getCommandReturn }
+module.exports = { getStepReturn }

package/src/{commands/run_command.js → steps/run_step.js}

@@ -2,23 +2,23 @@
 'use strict'
 
 const { addMutableConstants } = require('../core/constants')
-const { logCommand } = require('../log/messages/commands')
+const { logStepStart } = require('../log/messages/steps')
 const { runsAlsoOnBuildFailure, runsOnlyOnBuildFailure } = require('../plugins/events')
 const { measureDuration, normalizeTimerName } = require('../time/main')
 
-const { fireCoreCommand } = require('./core_command')
-const { firePluginCommand } = require('./plugin')
-const { getCommandReturn } = require('./return')
+const { fireCoreStep } = require('./core_step')
+const { firePluginStep } = require('./plugin')
+const { getStepReturn } = require('./return')
 
-// Run a command (shell or plugin)
-const runCommand = async function ({
+// Run a step (core, build command or plugin)
+const runStep = async function ({
   event,
   childProcess,
   packageName,
-  coreCommand,
-  coreCommandId,
-  coreCommandName,
-  coreCommandDescription,
+  coreStep,
+  coreStepId,
+  coreStepName,
+  coreStepDescription,
   pluginPackageJson,
   loadedFrom,
   origin,
@@ -33,7 +33,7 @@ const runCommand = async function ({
   branch,
   envChanges,
   constants,
-  commands,
+  steps,
   buildbotServerSocket,
   events,
   mode,
@@ -58,7 +58,7 @@ const runCommand = async function ({
   const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig })
 
   if (
-    !(await shouldRunCommand({
+    !(await shouldRunStep({
       event,
       packageName,
       error,
@@ -73,9 +73,9 @@ const runCommand = async function ({
     return {}
   }
 
-  logCommand({ logs, event, packageName, coreCommandDescription, index, error, netlifyConfig })
+  logStepStart({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig })
 
-  const fireCommand = getFireCommand(packageName, coreCommandId, event)
+  const fireStep = getFireStep(packageName, coreStepId, event)
   const {
     newEnvChanges,
     netlifyConfig: netlifyConfigA = netlifyConfig,
@@ -86,15 +86,15 @@ const runCommand = async function ({
     newStatus,
     timers: timersA,
     durationNs,
-  } = await fireCommand({
+  } = await fireStep({
     event,
     childProcess,
     packageName,
     pluginPackageJson,
     loadedFrom,
     origin,
-    coreCommand,
-    coreCommandName,
+    coreStep,
+    coreStepName,
     configPath,
     buildDir,
     repositoryRoot,
@@ -104,7 +104,7 @@ const runCommand = async function ({
     branch,
     envChanges,
     constants: constantsA,
-    commands,
+    steps,
     buildbotServerSocket,
     events,
     error,
@@ -121,14 +121,14 @@ const runCommand = async function ({
     featureFlags,
   })
 
-  const newValues = await getCommandReturn({
+  const newValues = await getStepReturn({
     event,
     packageName,
     newError,
     newEnvChanges,
     newStatus,
-    coreCommand,
-    coreCommandName,
+    coreStep,
+    coreStepName,
     childEnv,
     mode,
     api,
@@ -178,7 +178,7 @@ const runCommand = async function ({
 // or available. However, one might be created by a build plugin, in which case,
 // those core plugins should be triggered. We use a dynamic `condition()` to
 // model this behavior.
-const shouldRunCommand = async function ({
+const shouldRunStep = async function ({
   event,
   packageName,
   error,
@@ -203,25 +203,25 @@ const shouldRunCommand = async function ({
   return !runsOnlyOnBuildFailure(event)
 }
 
-// Wrap command function to measure its time
-const getFireCommand = function (packageName, coreCommandId, event) {
-  if (coreCommandId !== undefined) {
-    return measureDuration(tFireCommand, coreCommandId)
+// Wrap step function to measure its time
+const getFireStep = function (packageName, coreStepId, event) {
+  if (coreStepId !== undefined) {
+    return measureDuration(tFireStep, coreStepId)
   }
 
   const parentTag = normalizeTimerName(packageName)
-  return measureDuration(tFireCommand, event, { parentTag, category: 'pluginEvent' })
+  return measureDuration(tFireStep, event, { parentTag, category: 'pluginEvent' })
 }
 
-const tFireCommand = function ({
+const tFireStep = function ({
   event,
   childProcess,
   packageName,
   pluginPackageJson,
   loadedFrom,
   origin,
-  coreCommand,
-  coreCommandName,
+  coreStep,
+  coreStepName,
   configPath,
   buildDir,
   repositoryRoot,
@@ -231,7 +231,7 @@ const tFireCommand = function ({
   branch,
   envChanges,
   constants,
-  commands,
+  steps,
   buildbotServerSocket,
   events,
   error,
@@ -246,10 +246,10 @@ const tFireCommand = function ({
   redirectsPath,
   featureFlags,
 }) {
-  if (coreCommand !== undefined) {
-    return fireCoreCommand({
-      coreCommand,
-      coreCommandName,
+  if (coreStep !== undefined) {
+    return fireCoreStep({
+      coreStep,
+      coreStepName,
       configPath,
       buildDir,
       repositoryRoot,
@@ -274,7 +274,7 @@ const tFireCommand = function ({
     })
   }
 
-  return firePluginCommand({
+  return firePluginStep({
     event,
     childProcess,
     packageName,
@@ -289,12 +289,12 @@ const tFireCommand = function ({
     headersPath,
     redirectsPath,
     constants,
-    commands,
+    steps,
     error,
     logs,
     debug,
   })
 }
 
-module.exports = { runCommand }
+module.exports = { runStep }
 /* eslint-enable max-lines */

package/src/{commands/run_commands.js → steps/run_steps.js}

@@ -6,15 +6,15 @@ const pReduce = require('p-reduce')
 const { addErrorInfo } = require('../error/info')
 const { addStatus } = require('../status/add')
 
-const { runCommand } = require('./run_command')
+const { runStep } = require('./run_step')
 
-// Run all commands.
-// Each command can change some state: last `error`, environment variables changes,
+// Run all steps.
+// Each step can change some state: last `error`, environment variables changes,
 // list of `failedPlugins` (that ran `utils.build.failPlugin()`).
 // If an error arises, runs `onError` events.
 // Runs `onEnd` events at the end, whether an error was thrown or not.
-const runCommands = async function ({
-  commands,
+const runSteps = async function ({
+  steps,
   buildbotServerSocket,
   events,
   configPath,
@@ -42,7 +42,7 @@ const runCommands = async function ({
   featureFlags,
 }) {
   const {
-    index: commandsCount,
+    index: stepsCount,
     error: errorA,
     netlifyConfig: netlifyConfigC,
     statuses: statusesB,
@@ -50,7 +50,7 @@ const runCommands = async function ({
     timers: timersC,
     configMutations: configMutationsB,
   } = await pReduce(
-    commands,
+    steps,
     async (
       {
         index,
@@ -68,10 +68,10 @@ const runCommands = async function ({
         event,
         childProcess,
         packageName,
-        coreCommand,
-        coreCommandId,
-        coreCommandName,
-        coreCommandDescription,
+        coreStep,
+        coreStepId,
+        coreStepName,
+        coreStepDescription,
         pluginPackageJson,
         loadedFrom,
         origin,
@@ -89,14 +89,14 @@ const runCommands = async function ({
         redirectsPath: redirectsPathB = redirectsPathA,
         newStatus,
         timers: timersB = timersA,
-      } = await runCommand({
+      } = await runStep({
         event,
         childProcess,
         packageName,
-        coreCommand,
-        coreCommandId,
-        coreCommandName,
-        coreCommandDescription,
+        coreStep,
+        coreStepId,
+        coreStepName,
+        coreStepDescription,
         pluginPackageJson,
         loadedFrom,
         origin,
@@ -111,7 +111,7 @@ const runCommands = async function ({
         branch,
         envChanges,
         constants,
-        commands,
+        steps,
         buildbotServerSocket,
         events,
         mode,
@@ -168,7 +168,7 @@ const runCommands = async function ({
   }
 
   return {
-    commandsCount,
+    stepsCount,
     netlifyConfig: netlifyConfigC,
     statuses: statusesB,
     failedPlugins: failedPluginsA,
@@ -177,5 +177,5 @@ const runCommands = async function ({
   }
 }
 
-module.exports = { runCommands }
+module.exports = { runSteps }
 /* eslint-enable max-lines */

package/src/telemetry/main.js

@@ -21,7 +21,7 @@ const trackBuildComplete = async function ({
   deployId,
   buildId,
   status,
-  commandsCount,
+  stepsCount,
   pluginsOptions,
   durationNs,
   siteInfo,
@@ -39,7 +39,7 @@ const trackBuildComplete = async function ({
       deployId,
       buildId,
       status,
-      commandsCount,
+      stepsCount,
       pluginsOptions,
       durationNs,
       siteInfo,
@@ -73,7 +73,7 @@ const getPayload = function ({
   deployId,
   buildId,
   status,
-  commandsCount,
+  stepsCount,
   pluginsOptions,
   durationNs,
   userNodeVersion,
@@ -88,7 +88,7 @@ const getPayload = function ({
       deployId,
       buildId,
       status,
-      steps: commandsCount,
+      steps: stepsCount,
       buildVersion,
       // We're passing the node version set by the buildbot/user which will run the `build.command` and
       // the `package.json`/locally defined plugins

package/src/commands/get.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const { EVENTS } = require('../plugins/events')
-const { buildCommandCore } = require('../plugins_core/build_command')
-const { deploySite } = require('../plugins_core/deploy')
-const { bundleFunctions } = require('../plugins_core/functions')
-
-// Get commands for all events
-const getCommands = function (commands) {
-  const commandsA = addCoreCommands(commands)
-  const commandsB = sortCommands(commandsA)
-  const events = getEvents(commandsB)
-  return { commands: commandsB, events }
-}
-
-const addCoreCommands = function (commands) {
-  return [buildCommandCore, ...commands, bundleFunctions, deploySite]
-}
-
-// Sort plugin commands by event order.
-const sortCommands = function (commands) {
-  return EVENTS.flatMap((event) => commands.filter((command) => command.event === event))
-}
-
-// Retrieve list of unique events
-const getEvents = function (commands) {
-  const events = commands.map(getEvent)
-  return [...new Set(events)]
-}
-
-const getEvent = function ({ event }) {
-  return event
-}
-
-module.exports = { getCommands }

package/src/log/messages/commands.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const { getLogHeaderFunc } = require('../header_func')
-const { log, logMessage } = require('../logger')
-const { THEME } = require('../theme')
-
-const logCommand = function ({ logs, event, packageName, coreCommandDescription, index, error, netlifyConfig }) {
-  const description = getDescription({ coreCommandDescription, netlifyConfig, packageName, event })
-  const logHeaderFunc = getLogHeaderFunc(error)
-  logHeaderFunc(logs, `${index + 1}. ${description}`)
-  logMessage(logs, '')
-}
-
-const getDescription = function ({ coreCommandDescription, netlifyConfig, packageName, event }) {
-  return coreCommandDescription === undefined
-    ? `${event} command from ${packageName}`
-    : coreCommandDescription({ netlifyConfig })
-}
-
-const logBuildCommandStart = function (logs, buildCommand) {
-  log(logs, THEME.highlightWords(`$ ${buildCommand}`))
-}
-
-const logCommandSuccess = function (logs) {
-  logMessage(logs, '')
-}
-
-module.exports = {
-  logCommand,
-  logBuildCommandStart,
-  logCommandSuccess,
-}