@netlify/build 29.0.1-rc → 29.0.2

package/src/steps/run_core_steps.js

@@ -1,200 +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, getSystemLogger } 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 }
-  const systemLog = getSystemLogger(logs, debug)
-
-  try {
-    const { netlifyConfig: netlifyConfigA, configMutations } = await executeBuildStep({
-      ...flagsA,
-      errorMonitor,
-      mode,
-      logs,
-      debug,
-      errorParams,
-      buildSteps,
-      systemLog,
-    })
-    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,
-  systemLog,
-}) {
-  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,
-      systemLog,
-    })
-
-    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,
-  systemLog,
-}) {
-  const { netlifyConfig: netlifyConfigA, configMutations } = await runSteps({
-    steps: getBuildSteps(buildSteps),
-    buildDir,
-    nodePath,
-    constants,
-    netlifyConfig,
-    logs,
-    debug,
-    timers: [],
-    featureFlags,
-    childEnv,
-    repositoryRoot,
-    systemLog,
-  })
-
-  return { netlifyConfig: netlifyConfigA, configMutations }
-}

package/src/steps/run_step.js

@@ -1,304 +0,0 @@
-import { addMutableConstants } from '../core/constants.js'
-import { logStepStart } from '../log/messages/steps.js'
-import { runsAlsoOnBuildFailure, runsOnlyOnBuildFailure } from '../plugins/events.js'
-import { measureDuration, normalizeTimerName } from '../time/main.js'
-
-import { fireCoreStep } from './core_step.js'
-import { firePluginStep } from './plugin.js'
-import { getStepReturn } from './return.js'
-
-// Run a step (core, build command or plugin)
-export const runStep = async function ({
-  event,
-  childProcess,
-  packageName,
-  coreStep,
-  coreStepId,
-  coreStepName,
-  coreStepDescription,
-  pluginPackageJson,
-  loadedFrom,
-  origin,
-  condition,
-  configPath,
-  buildDir,
-  repositoryRoot,
-  nodePath,
-  index,
-  childEnv,
-  context,
-  branch,
-  envChanges,
-  constants,
-  steps,
-  buildbotServerSocket,
-  events,
-  mode,
-  api,
-  errorMonitor,
-  deployId,
-  errorParams,
-  error,
-  failedPlugins,
-  configOpts,
-  netlifyConfig,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  logs,
-  debug,
-  systemLog,
-  verbose,
-  saveConfig,
-  timers,
-  testOpts,
-  featureFlags,
-}) {
-  const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig })
-
-  if (
-    !(await shouldRunStep({
-      event,
-      packageName,
-      error,
-      failedPlugins,
-      netlifyConfig,
-      condition,
-      constants: constantsA,
-      buildbotServerSocket,
-      buildDir,
-    }))
-  ) {
-    return {}
-  }
-
-  logStepStart({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig })
-
-  const fireStep = getFireStep(packageName, coreStepId, event)
-  const {
-    newEnvChanges,
-    netlifyConfig: netlifyConfigA = netlifyConfig,
-    configMutations: configMutationsA = configMutations,
-    headersPath: headersPathA = headersPath,
-    redirectsPath: redirectsPathA = redirectsPath,
-    newError,
-    newStatus,
-    timers: timersA,
-    durationNs,
-  } = await fireStep({
-    event,
-    childProcess,
-    packageName,
-    pluginPackageJson,
-    loadedFrom,
-    origin,
-    coreStep,
-    coreStepName,
-    configPath,
-    buildDir,
-    repositoryRoot,
-    nodePath,
-    childEnv,
-    context,
-    branch,
-    envChanges,
-    constants: constantsA,
-    steps,
-    buildbotServerSocket,
-    events,
-    error,
-    logs,
-    debug,
-    systemLog,
-    verbose,
-    saveConfig,
-    timers,
-    errorParams,
-    configOpts,
-    netlifyConfig,
-    configMutations,
-    headersPath,
-    redirectsPath,
-    featureFlags,
-  })
-
-  const newValues = await getStepReturn({
-    event,
-    packageName,
-    newError,
-    newEnvChanges,
-    newStatus,
-    coreStep,
-    coreStepName,
-    childEnv,
-    mode,
-    api,
-    errorMonitor,
-    deployId,
-    netlifyConfig: netlifyConfigA,
-    configMutations: configMutationsA,
-    headersPath: headersPathA,
-    redirectsPath: redirectsPathA,
-    logs,
-    debug,
-    systemLog,
-    timers: timersA,
-    durationNs,
-    testOpts,
-  })
-  return { ...newValues, newIndex: index + 1 }
-}
-
-// A plugin fails _without making the build fail_ when either:
-//   - using `utils.build.failPlugin()`
-//   - the failure happens after deploy. This means: inside any `onError`,
-//     `onSuccess` or `onEnd` event handler.
-//
-// When that happens, no other events for that specific plugin is run.
-// Not even `onError` and `onEnd`.
-// Plugins should use `try`/`catch`/`finally` blocks to handle exceptions,
-// not `onError` nor `onEnd`.
-//
-// Otherwise, most failures will make the build fail. This includes:
-//   - the build command failed
-//   - Functions or Edge Functions bundling failed
-//   - the deploy failed (deploying files to our CDN)
-//   - a plugin `onPreBuild`, `onBuild` or `onPostBuild` event handler failed.
-//     This includes uncaught exceptions and using `utils.build.failBuild()`
-//     or `utils.build.cancelBuild()`.
-//
-// `onError` is triggered when the build failed.
-// It means "on build failure" not "on plugin failure".
-// `onSuccess` is the opposite. It is triggered after the build succeeded.
-// `onEnd` is triggered after the build either failed or succeeded.
-// It is useful for resources cleanup.
-//
-// Finally, some plugins (only core plugins for the moment) might be enabled or
-// not depending on whether a specific action is happening during the build,
-// such as creating a file. For example, the Functions and Edge Functions core
-// plugins are disabled if no Functions or Edge Functions directory is specified
-// 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 shouldRunStep = async function ({
-  event,
-  packageName,
-  error,
-  failedPlugins,
-  netlifyConfig,
-  condition,
-  constants,
-  buildbotServerSocket,
-  buildDir,
-}) {
-  if (
-    failedPlugins.includes(packageName) ||
-    (condition !== undefined && !(await condition({ buildDir, constants, buildbotServerSocket, netlifyConfig })))
-  ) {
-    return false
-  }
-
-  if (error !== undefined) {
-    return runsAlsoOnBuildFailure(event)
-  }
-
-  return !runsOnlyOnBuildFailure(event)
-}
-
-// 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(tFireStep, event, { parentTag, category: 'pluginEvent' })
-}
-
-const tFireStep = function ({
-  event,
-  childProcess,
-  packageName,
-  pluginPackageJson,
-  loadedFrom,
-  origin,
-  coreStep,
-  coreStepName,
-  configPath,
-  buildDir,
-  repositoryRoot,
-  nodePath,
-  childEnv,
-  context,
-  branch,
-  envChanges,
-  constants,
-  steps,
-  buildbotServerSocket,
-  events,
-  error,
-  logs,
-  debug,
-  systemLog,
-  verbose,
-  saveConfig,
-  errorParams,
-  configOpts,
-  netlifyConfig,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  featureFlags,
-}) {
-  if (coreStep !== undefined) {
-    return fireCoreStep({
-      coreStep,
-      coreStepName,
-      configPath,
-      buildDir,
-      repositoryRoot,
-      constants,
-      buildbotServerSocket,
-      events,
-      logs,
-      nodePath,
-      childEnv,
-      context,
-      branch,
-      envChanges,
-      errorParams,
-      configOpts,
-      netlifyConfig,
-      configMutations,
-      headersPath,
-      redirectsPath,
-      featureFlags,
-      debug,
-      systemLog,
-      saveConfig,
-    })
-  }
-
-  return firePluginStep({
-    event,
-    childProcess,
-    packageName,
-    pluginPackageJson,
-    loadedFrom,
-    origin,
-    envChanges,
-    errorParams,
-    configOpts,
-    netlifyConfig,
-    configMutations,
-    headersPath,
-    redirectsPath,
-    constants,
-    steps,
-    error,
-    logs,
-    debug,
-    systemLog,
-    verbose,
-  })
-}

package/src/steps/run_steps.js

@@ -1,179 +0,0 @@
-import pReduce from 'p-reduce'
-
-import { addErrorInfo } from '../error/info.js'
-import { addStatus } from '../status/add.js'
-
-import { runStep } from './run_step.js'
-
-// 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.
-export const runSteps = async function ({
-  steps,
-  buildbotServerSocket,
-  events,
-  configPath,
-  headersPath,
-  redirectsPath,
-  buildDir,
-  repositoryRoot,
-  nodePath,
-  childEnv,
-  context,
-  branch,
-  constants,
-  mode,
-  api,
-  errorMonitor,
-  deployId,
-  errorParams,
-  netlifyConfig,
-  configOpts,
-  logs,
-  debug,
-  systemLog,
-  verbose,
-  saveConfig,
-  timers,
-  testOpts,
-  featureFlags,
-}) {
-  const {
-    index: stepsCount,
-    error: errorA,
-    netlifyConfig: netlifyConfigC,
-    statuses: statusesB,
-    failedPlugins: failedPluginsA,
-    timers: timersC,
-    configMutations: configMutationsB,
-  } = await pReduce(
-    steps,
-    async (
-      {
-        index,
-        error,
-        failedPlugins,
-        envChanges,
-        netlifyConfig: netlifyConfigA,
-        configMutations,
-        headersPath: headersPathA,
-        redirectsPath: redirectsPathA,
-        statuses,
-        timers: timersA,
-      },
-      {
-        event,
-        childProcess,
-        packageName,
-        coreStep,
-        coreStepId,
-        coreStepName,
-        coreStepDescription,
-        pluginPackageJson,
-        loadedFrom,
-        origin,
-        condition,
-      },
-    ) => {
-      const {
-        newIndex = index,
-        newError = error,
-        failedPlugin = [],
-        newEnvChanges = {},
-        netlifyConfig: netlifyConfigB = netlifyConfigA,
-        configMutations: configMutationsA = configMutations,
-        headersPath: headersPathB = headersPathA,
-        redirectsPath: redirectsPathB = redirectsPathA,
-        newStatus,
-        timers: timersB = timersA,
-      } = await runStep({
-        event,
-        childProcess,
-        packageName,
-        coreStep,
-        coreStepId,
-        coreStepName,
-        coreStepDescription,
-        pluginPackageJson,
-        loadedFrom,
-        origin,
-        condition,
-        configPath,
-        buildDir,
-        repositoryRoot,
-        nodePath,
-        index,
-        childEnv,
-        context,
-        branch,
-        envChanges,
-        constants,
-        steps,
-        buildbotServerSocket,
-        events,
-        mode,
-        api,
-        errorMonitor,
-        deployId,
-        errorParams,
-        error,
-        failedPlugins,
-        configOpts,
-        netlifyConfig: netlifyConfigA,
-        configMutations,
-        headersPath: headersPathA,
-        redirectsPath: redirectsPathA,
-        logs,
-        debug,
-        systemLog,
-        verbose,
-        saveConfig,
-        timers: timersA,
-        testOpts,
-        featureFlags,
-      })
-      const statusesA = addStatus({ newStatus, statuses, event, packageName, pluginPackageJson })
-      return {
-        index: newIndex,
-        error: newError,
-        failedPlugins: [...failedPlugins, ...failedPlugin],
-        envChanges: { ...envChanges, ...newEnvChanges },
-        netlifyConfig: netlifyConfigB,
-        configMutations: configMutationsA,
-        headersPath: headersPathB,
-        redirectsPath: redirectsPathB,
-        statuses: statusesA,
-        timers: timersB,
-      }
-    },
-    {
-      index: 0,
-      failedPlugins: [],
-      envChanges: {},
-      netlifyConfig,
-      configMutations: [],
-      headersPath,
-      redirectsPath,
-      statuses: [],
-      timers,
-    },
-  )
-
-  // Instead of throwing any build failure right away, we wait for `onError`,
-  // etc. to complete. This is why we are throwing only now.
-  if (errorA !== undefined) {
-    addErrorInfo(errorA, { statuses: statusesB })
-    throw errorA
-  }
-
-  return {
-    stepsCount,
-    netlifyConfig: netlifyConfigC,
-    statuses: statusesB,
-    failedPlugins: failedPluginsA,
-    timers: timersC,
-    configMutations: configMutationsB,
-  }
-}