@netlify/build 27.20.4 → 27.20.6

package/lib/status/report.js

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

package/lib/status/success.js

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

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

package/lib/steps/error.js

@@ -1,9 +1,8 @@
-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'
-
+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
@@ -11,92 +10,56 @@ import { isSoftFailEvent } from '../plugins/events.js'
 //    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 })
-}
-
+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 }
-}
-
+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 }
-}
-
+    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 }
-}
-
+    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' }
-}
-
+    if (!isCorePluginBug(error, loadedFrom)) {
+        return {};
+    }
+    return { type: 'corePlugin' };
+};
 const isCorePluginBug = function (error, loadedFrom) {
-  const { severity } = parseErrorInfo(error)
-  return severity === 'warning' && loadedFrom === 'core'
-}
+    const { severity } = parseErrorInfo(error);
+    return severity === 'warning' && loadedFrom === 'core';
+};

package/lib/steps/get.js

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