@netlify/build 29.0.1-rc → 29.0.2

package/lib/plugins_core/functions/index.js

@@ -0,0 +1,114 @@
+import { resolve } from 'path';
+import { zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { pathExists } from 'path-exists';
+import { log } from '../../log/logger.js';
+import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js';
+import { getZipError } from './error.js';
+import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
+import { getZisiParameters } from './zisi.js';
+// Returns `true` if at least one of the functions has been configured to use
+// esbuild.
+const isUsingEsbuild = (functionsConfig = {}) => Object.values(functionsConfig).some((configObject) => configObject.node_bundler === 'esbuild');
+const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, }) => {
+    const zisiParameters = getZisiParameters({
+        buildDir,
+        childEnv,
+        featureFlags,
+        functionsConfig,
+        functionsDist,
+        internalFunctionsSrc,
+        isRunningLocally,
+        repositoryRoot,
+    });
+    const bundler = isUsingEsbuild(functionsConfig) ? 'esbuild' : 'zisi';
+    try {
+        // Printing an empty line before bundling output.
+        log(logs, '');
+        const sourceDirectories = [internalFunctionsSrc, functionsSrc].filter(Boolean);
+        const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters);
+        logBundleResults({ logs, results });
+        return { bundler };
+    }
+    catch (error) {
+        throw await getZipError(error, functionsSrc);
+    }
+};
+// Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
+const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, }) {
+    const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
+    const functionsDist = resolve(buildDir, relativeFunctionsDist);
+    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
+    const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
+    const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, logs, relativeFunctionsSrc });
+    const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
+        featureFlags,
+        functionsSrc,
+        functionsSrcExists,
+        internalFunctionsSrc,
+        internalFunctionsSrcExists,
+    });
+    if (functionsSrc && !functionsSrcExists) {
+        logFunctionsNonExistingDir(logs, relativeFunctionsSrc);
+        if (internalFunctions.length !== 0) {
+            log(logs, '');
+        }
+    }
+    logFunctionsToBundle({
+        logs,
+        userFunctions,
+        userFunctionsSrc: relativeFunctionsSrc,
+        userFunctionsSrcExists: functionsSrcExists,
+        internalFunctions,
+        internalFunctionsSrc: relativeInternalFunctionsSrc,
+    });
+    if (userFunctions.length === 0 && internalFunctions.length === 0) {
+        return {};
+    }
+    const { bundler } = await zipFunctionsAndLogResults({
+        buildDir,
+        childEnv,
+        featureFlags,
+        functionsConfig: netlifyConfig.functions,
+        functionsDist,
+        functionsSrc,
+        internalFunctionsSrc,
+        isRunningLocally,
+        logs,
+        repositoryRoot,
+    });
+    return {
+        tags: {
+            bundler,
+        },
+    };
+};
+// 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.
+const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }) {
+    const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== '';
+    if (hasFunctionsSrc) {
+        return true;
+    }
+    const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC);
+    return await pathExists(internalFunctionsSrc);
+};
+export const bundleFunctions = {
+    event: 'onBuild',
+    coreStep,
+    coreStepId: 'functions_bundling',
+    coreStepName: 'Functions bundling',
+    coreStepDescription: () => 'Functions bundling',
+    condition: hasFunctionsDirectories,
+};
+// Named imports with ES modules cannot be mocked (unlike CommonJS) because
+// they are bound at load time.
+// However, some of our tests are asserting which arguments are passed to
+// `zip-it-and-ship-it` methods. Therefore, we need to use an intermediary
+// function and export them so tests can use it.
+export const zipItAndShipIt = {
+    async zipFunctions(...args) {
+        return await zipFunctions(...args);
+    },
+};

package/lib/plugins_core/functions/utils.js

@@ -0,0 +1,45 @@
+import { promises as fs } from 'fs';
+import { relative } from 'path';
+import { listFunctions } from '@netlify/zip-it-and-ship-it';
+import { addErrorInfo } from '../../error/info.js';
+import { getZisiFeatureFlags } from './feature_flags.js';
+// Returns the `mainFile` of each function found in `functionsSrc`, relative to
+// `functionsSrc`.
+const getRelativeFunctionMainFiles = async function ({ featureFlags, functionsSrc }) {
+    if (functionsSrc === undefined) {
+        return [];
+    }
+    const zisiFeatureFlags = getZisiFeatureFlags(featureFlags);
+    const functions = await listFunctions(functionsSrc, { featureFlags: zisiFeatureFlags });
+    return functions.map(({ mainFile }) => relative(functionsSrc, mainFile));
+};
+export const getUserAndInternalFunctions = ({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, }) => {
+    const paths = [
+        functionsSrcExists ? functionsSrc : undefined,
+        internalFunctionsSrcExists ? internalFunctionsSrc : undefined,
+    ];
+    return Promise.all(paths.map((path) => path && getRelativeFunctionMainFiles({ featureFlags, functionsSrc: path })));
+};
+// Returns `true` if the functions directory exists and is valid. Returns
+// `false` if it doesn't exist. Throws an error if it's invalid or can't
+// be accessed.
+export const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSrc }) {
+    if (functionsSrc === undefined) {
+        return false;
+    }
+    try {
+        const stats = await fs.stat(functionsSrc);
+        if (stats.isDirectory()) {
+            return true;
+        }
+        const error = new Error(`The Netlify Functions setting should target a directory, not a regular file: ${relativeFunctionsSrc}`);
+        addErrorInfo(error, { type: 'resolveConfig' });
+        throw error;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+};

package/lib/plugins_core/functions/zisi.js

@@ -0,0 +1,39 @@
+import { join, resolve } from 'path';
+import mapObject from 'map-obj';
+import { getZisiFeatureFlags } from './feature_flags.js';
+export const getZisiParameters = ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, }) => {
+    const nodeVersion = childEnv.AWS_LAMBDA_JS_RUNTIME;
+    const manifest = join(functionsDist, 'manifest.json');
+    const config = mapObject(functionsConfig, (expression, object) => [
+        expression,
+        normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally, nodeVersion }),
+    ]);
+    const zisiFeatureFlags = getZisiFeatureFlags(featureFlags);
+    // Only internal functions are allowed to have a json config file
+    const configFileDirectories = [resolve(internalFunctionsSrc)];
+    return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot, configFileDirectories };
+};
+// The function configuration keys returned by @netlify/config are not an exact
+// match to the properties that @netlify/zip-it-and-ship-it expects. We do that
+// translation here.
+export const normalizeFunctionConfig = ({ buildDir, functionConfig = {}, isRunningLocally, nodeVersion }) => ({
+    externalNodeModules: functionConfig.external_node_modules,
+    includedFiles: functionConfig.included_files,
+    includedFilesBasePath: buildDir,
+    ignoredNodeModules: functionConfig.ignored_node_modules,
+    nodeVersion,
+    schedule: functionConfig.schedule,
+    // When the user selects esbuild as the Node bundler, we still want to use
+    // the legacy ZISI bundler as a fallback. Rather than asking the user to
+    // make this decision, we abstract that complexity away by injecting the
+    // fallback behavior ourselves. We do this by transforming the value
+    // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
+    nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
+    // If the build is running in buildbot, we set the Rust target directory to a
+    // path that will get cached in between builds, allowing us to speed up the
+    // build process.
+    rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
+    // Go functions should be zipped only when building locally. When running in
+    // buildbot, the Go API client will handle the zipping.
+    zipGo: isRunningLocally ? true : undefined,
+});

package/{src → lib}/plugins_core/functions_install/index.js

@@ -1,13 +1,10 @@
-import { pathExists } from 'path-exists'
-
-import { installFunctionDependencies } from '../../install/functions.js'
-
+import { pathExists } from 'path-exists';
+import { installFunctionDependencies } from '../../install/functions.js';
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
 export const onPreBuild = async function ({ constants: { FUNCTIONS_SRC, IS_LOCAL } }) {
-  if (!(await pathExists(FUNCTIONS_SRC))) {
-    return {}
-  }
-
-  await installFunctionDependencies(FUNCTIONS_SRC, IS_LOCAL)
-  return {}
-}
+    if (!(await pathExists(FUNCTIONS_SRC))) {
+        return {};
+    }
+    await installFunctionDependencies(FUNCTIONS_SRC, IS_LOCAL);
+    return {};
+};

package/lib/plugins_core/list.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from 'url';
+import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js';
+const FUNCTIONS_INSTALL_PLUGIN = fileURLToPath(new URL('functions_install/index.js', import.meta.url));
+// List of core plugin names
+const FUNCTIONS_INSTALL_PLUGIN_NAME = '@netlify/plugin-functions-install-core';
+const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME]);
+// Plugins that are installed and enabled by default
+export const listCorePlugins = function ({ FUNCTIONS_SRC }) {
+    const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC);
+    return [functionsInstallPlugin].filter(Boolean);
+};
+const getFunctionsInstallPlugin = function (FUNCTIONS_SRC) {
+    if (FUNCTIONS_SRC === undefined) {
+        return;
+    }
+    return { package: FUNCTIONS_INSTALL_PLUGIN_NAME, pluginPath: FUNCTIONS_INSTALL_PLUGIN, optional: true };
+};
+export const isCorePlugin = function (packageName) {
+    return CORE_PLUGINS.has(packageName);
+};

package/lib/report/statsd.js

@@ -0,0 +1,31 @@
+import { promisify } from 'util';
+import slugify from '@sindresorhus/slugify';
+import StatsdClient from 'statsd-client';
+// TODO: replace with `timers/promises` after dropping Node < 15.0.0
+const pSetTimeout = promisify(setTimeout);
+// See https://github.com/msiebuhr/node-statsd-client/blob/45a93ee4c94ca72f244a40b06cb542d4bd7c3766/lib/EphemeralSocket.js#L81
+const CLOSE_TIMEOUT = 11;
+// The socket creation is delayed until the first packet is sent. In our
+// case, this happens just before `client.close()` is called, which is too
+// late and make it not send anything. We need to manually create it using
+// the internal API.
+export const startClient = async function (host, port) {
+    const client = new StatsdClient({ host, port, socketTimeout: 0 });
+    // @ts-expect-error using internals :D
+    await promisify(client._socket._createSocket.bind(client._socket))();
+    return client;
+};
+// UDP packets are buffered and flushed at regular intervals by statsd-client.
+// Closing force flushing all of them.
+export const closeClient = async function (client) {
+    client.close();
+    // statsd-client does not provide a way of knowing when the socket is done
+    // closing, so we need to use the following hack.
+    await pSetTimeout(CLOSE_TIMEOUT);
+    await pSetTimeout(CLOSE_TIMEOUT);
+};
+// Make sure the timer name does not include special characters.
+// For example, the `packageName` of local plugins includes dots.
+export const normalizeTagName = function (name) {
+    return slugify(name, { separator: '_' });
+};

package/lib/status/add.js

@@ -0,0 +1,30 @@
+// Merge plugin status to the list of plugin statuses.
+export const addStatus = function ({ newStatus, statuses, event, packageName, pluginPackageJson: { version } = {} }) {
+    // Either:
+    //  - `build.command`
+    //  - no status was set
+    if (newStatus === undefined) {
+        return statuses;
+    }
+    const formerStatus = statuses.find((status) => status.packageName === packageName);
+    if (!canOverrideStatus(formerStatus, newStatus)) {
+        return statuses;
+    }
+    // Overrides plugin's previous status and add more information
+    const newStatuses = statuses.filter((status) => status !== formerStatus);
+    return [...newStatuses, { ...newStatus, event, packageName, version }];
+};
+const canOverrideStatus = function (formerStatus, newStatus) {
+    // No previous status
+    if (formerStatus === undefined) {
+        return true;
+    }
+    // Implicit statuses can never override
+    if (newStatus.implicit) {
+        return false;
+    }
+    // Error statuses can only be overwritten by more severe error statuses
+    return STATES.indexOf(formerStatus.state) <= STATES.indexOf(newStatus.state);
+};
+// Possible status states, ordered by severity.
+const STATES = ['success', 'canceled_plugin', 'failed_plugin', 'failed_build'];

package/lib/status/colors.js

@@ -0,0 +1,18 @@
+import stripAnsi from 'strip-ansi';
+// Remove colors from statuses
+export const removeStatusesColors = function (statuses) {
+    return statuses.map(removeStatusColors);
+};
+const removeStatusColors = function (status) {
+    const attributes = COLOR_ATTRIBUTES.map((attribute) => removeAttrColor(status, attribute));
+    return Object.assign({}, status, ...attributes);
+};
+const COLOR_ATTRIBUTES = ['title', 'summary', 'text'];
+const removeAttrColor = function (status, attribute) {
+    const value = status[attribute];
+    if (value === undefined) {
+        return {};
+    }
+    const valueA = stripAnsi(value);
+    return { [attribute]: valueA };
+};

package/lib/status/load_error.js

@@ -0,0 +1,10 @@
+import { addErrorInfo } from '../error/info.js';
+import { getFullErrorInfo } from '../error/parse/parse.js';
+import { serializeErrorStatus } from '../error/parse/serialize_status.js';
+// Errors that happen during plugin loads should be reported as error statuses
+export const addPluginLoadErrorStatus = function ({ error, packageName, version, debug }) {
+    const fullErrorInfo = getFullErrorInfo({ error, colors: false, debug });
+    const errorStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' });
+    const statuses = [{ ...errorStatus, event: 'load', packageName, version }];
+    addErrorInfo(error, { statuses });
+};

package/lib/status/report.js

@@ -0,0 +1,83 @@
+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,
+    });
+};
+// 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));
+};
+const getPluginStatus = function (packageName, statuses) {
+    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);
+};
+const shouldPrintStatus = function ({ state, summary }) {
+    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 });
+    }
+};

package/lib/status/success.js

@@ -0,0 +1,14 @@
+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;
+};
+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/lib/steps/core_step.js

@@ -0,0 +1,59 @@
+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, coreStepId, 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 } });
+        }
+        // always add the current stage
+        addErrorInfo(newError, { stage: coreStepId });
+        return { newError };
+    }
+};

package/lib/steps/error.js

@@ -0,0 +1,65 @@
+import { cancelBuild } from '../error/cancel.js';
+import { handleBuildError } from '../error/handle.js';
+import { getFullErrorInfo, parseErrorInfo } from '../error/parse/parse.js';
+import { serializeErrorStatus } from '../error/parse/serialize_status.js';
+import { isSoftFailEvent } from '../plugins/events.js';
+// Handle build command errors and plugin errors:
+//  - usually, propagate the error to make the build stop.
+//  - `utils.build.cancelBuild()` also cancels the build by calling the API
+//  - `utils.build.failPlugin()` or post-deploy errors do not make the build
+//    stop, but are still reported, and prevent future events from the same
+//    plugin.
+// This also computes error statuses that are sent to the API.
+export const handleStepError = function ({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }) {
+    // Core steps do not report error statuses
+    if (coreStep !== undefined) {
+        return { newError };
+    }
+    const fullErrorInfo = getFullErrorInfo({ error: newError, colors: false, debug });
+    const { type } = fullErrorInfo;
+    if (type === 'failPlugin' || isSoftFailEvent(event)) {
+        return handleFailPlugin({
+            fullErrorInfo,
+            newError,
+            childEnv,
+            mode,
+            errorMonitor,
+            netlifyConfig,
+            logs,
+            debug,
+            testOpts,
+        });
+    }
+    if (type === 'cancelBuild') {
+        return handleCancelBuild({ fullErrorInfo, newError, api, deployId });
+    }
+    return handleFailBuild({ fullErrorInfo, newError });
+};
+// On `utils.build.failPlugin()` or during `onSuccess` or `onEnd`
+const handleFailPlugin = async function ({ fullErrorInfo, fullErrorInfo: { errorInfo: { location: { packageName } = {} }, }, newError, childEnv, mode, errorMonitor, netlifyConfig, logs, debug, testOpts, }) {
+    const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_plugin' });
+    await handleBuildError(newError, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts });
+    return { failedPlugin: [packageName], newStatus };
+};
+// On `utils.build.cancelBuild()`
+const handleCancelBuild = async function ({ fullErrorInfo, newError, api, deployId }) {
+    const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'canceled_build' });
+    await cancelBuild({ api, deployId });
+    return { newError, newStatus };
+};
+// On `utils.build.failBuild()` or uncaught exception
+const handleFailBuild = function ({ fullErrorInfo, newError }) {
+    const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' });
+    return { newError, newStatus };
+};
+// Unlike community plugins, core plugin bugs should be handled as system errors
+export const getPluginErrorType = function (error, loadedFrom) {
+    if (!isCorePluginBug(error, loadedFrom)) {
+        return {};
+    }
+    return { type: 'corePlugin' };
+};
+const isCorePluginBug = function (error, loadedFrom) {
+    const { severity } = parseErrorInfo(error);
+    return severity === 'warning' && loadedFrom === 'core';
+};

package/lib/steps/get.js

@@ -0,0 +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';
+// 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 };
+};
+// 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 addCoreSteps = function (steps) {
+    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));
+};
+// Retrieve list of unique events
+const getEvents = function (steps) {
+    const events = steps.map(getEvent);
+    return [...new Set(events)];
+};
+const getEvent = function ({ event }) {
+    return event;
+};

package/lib/steps/plugin.js

@@ -0,0 +1,55 @@
+import { addErrorInfo } from '../error/info.js';
+import { logStepCompleted } from '../log/messages/ipc.js';
+import { pipePluginOutput, unpipePluginOutput } from '../log/stream.js';
+import { callChild } from '../plugins/ipc.js';
+import { getSuccessStatus } from '../status/success.js';
+import { getPluginErrorType } from './error.js';
+import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
+// Fire a plugin step
+export const firePluginStep = async function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, debug, verbose, }) {
+    const listeners = pipePluginOutput(childProcess, logs);
+    try {
+        const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
+        const { newEnvChanges, configMutations: newConfigMutations, status, } = await callChild({
+            childProcess,
+            eventName: 'run',
+            payload: { event, error, envChanges, netlifyConfig, constants },
+            logs,
+            verbose,
+        });
+        const { netlifyConfig: netlifyConfigA, configMutations: configMutationsA, headersPath: headersPathA, redirectsPath: redirectsPathA, } = await updateNetlifyConfig({
+            configOpts,
+            netlifyConfig,
+            headersPath,
+            redirectsPath,
+            configMutations,
+            newConfigMutations,
+            configSideFiles,
+            errorParams,
+            logs,
+            debug,
+        });
+        const newStatus = getSuccessStatus(status, { steps, event, packageName });
+        return {
+            newEnvChanges,
+            netlifyConfig: netlifyConfigA,
+            configMutations: configMutationsA,
+            headersPath: headersPathA,
+            redirectsPath: redirectsPathA,
+            newStatus,
+        };
+    }
+    catch (newError) {
+        const errorType = getPluginErrorType(newError, loadedFrom);
+        addErrorInfo(newError, {
+            ...errorType,
+            plugin: { pluginPackageJson, packageName },
+            location: { event, packageName, loadedFrom, origin },
+        });
+        return { newError };
+    }
+    finally {
+        await unpipePluginOutput(childProcess, logs, listeners);
+        logStepCompleted(logs, verbose);
+    }
+};