@netlify/build 18.13.12 → 18.15.1

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/types/config/build.d.ts

@@ -0,0 +1,61 @@
+import { JSONValue } from '../utils/json_value'
+
+interface NetlifyPlugin {
+  package: string
+  inputs: JSONValue
+}
+
+/* eslint-disable camelcase -- some properties are named in snake case in this API */
+
+export interface Build {
+  /**
+   * Includes a site's [build command](https://docs.netlify.com/configure-builds/get-started/#definitions)
+   */
+  command?: string
+
+  /**
+   * the path to your static content folder
+   */
+  publish: string
+  base: string
+  services: Record<string, unknown>
+
+  /**
+   * Allows specifying a Bash command that will be run from the base directory to determine whether the site needs rebuilding or not.
+   * Check out our [ignore builds](https://docs.netlify.com/configure-builds/common-configurations/ignore-builds/) doc for more information on the default ignore behavior and details about constructing a custom ignore command.
+   */
+  ignore?: string
+
+  /**
+   * Includes the path to a site's [Edge Handlers directory](https://docs.netlify.com/edge-handlers/configure-and-build/#choose-an-edge-handlers-directory)
+   */
+  edge_handlers?: string
+  /**
+   * Contains a site's [environment variables](https://docs.netlify.com/configure-builds/environment-variables/#netlify-configuration-variables)
+   */
+  environment: Partial<Record<string, string>>
+  /**
+   * Includes options for [post processing](https://docs.netlify.com/configure-builds/file-based-configuration/#post-processing) HTML, CSS, JavaScript, and images
+   */
+  processing: {
+    skip_processing?: boolean
+    css: {
+      bundle?: boolean
+      minify?: boolean
+    }
+    js: {
+      bundle?: boolean
+      minify?: boolean
+    }
+    html: {
+      pretty_url?: boolean
+    }
+    images: {
+      compress?: boolean
+    }
+  }
+
+  plugins: readonly NetlifyPlugin[]
+}
+
+/* eslint-enable camelcase */

package/types/config/functions.d.ts

@@ -0,0 +1,38 @@
+type GlobPattern = string
+
+/* eslint-disable camelcase -- some properties are named in snake case in this API */
+type FunctionsObject = {
+  /**
+   * string that includes the path to a site's [functions directory](https://docs.netlify.com/functions/configure-and-deploy/#configure-the-functions-folder)
+   */
+  directory: string
+} & (
+  | {
+      /**
+       * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).
+       */
+      node_bundler: 'zisi'
+    }
+  | {
+      /**
+       * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).
+       */
+      node_bundler: 'esbuild'
+
+      /**
+       * a list of Node.js modules that are copied to the bundled artifact without adjusting their source or references during the bundling process.
+       * This property helps handle dependencies that can’t be inlined, such as modules with native add-ons.
+       */
+      external_node_modules: string[]
+
+      /**
+       * a list of additional paths to include in the function bundle. Although our build system includes statically referenced files (like `require("./some-file.js")`) by default, `included_files` lets you specify additional files or directories and reference them dynamically in function code. You can use `*` to match any character or prefix an entry with `!` to exclude files. Paths are relative to the [base directory](https://docs.netlify.com/configure-builds/get-started/#definitions-1).
+       */
+      included_files: string[]
+
+      ignored_node_modules: string[]
+    }
+)
+/* eslint-enable camelcase */
+
+export type Functions = Record<GlobPattern, FunctionsObject>