@netlify/build 0.4.48 → 1.0.0-dl-test

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,64 @@
+import { join, resolve } from 'path';
+import mapObject from 'map-obj';
+import semver from 'semver';
+import { getZisiFeatureFlags } from './feature_flags.js';
+const getLambdaNodeVersion = (childEnv, userNodeVersion) => {
+    if (childEnv.AWS_LAMBDA_JS_RUNTIME) {
+        return childEnv.AWS_LAMBDA_JS_RUNTIME;
+    }
+    // As of time of writing the default Lambda Node.js version is 16 and
+    // we do not want to take the risk and downgrade users from this default version on initial release
+    // of the dependency between user and lambda Node.js version.
+    // The check ensures that if the user version is lower than 16 we keep the default version.
+    //
+    // TODO: Remove this once Node.js 16 is deprecated. Do NOT change this if the default Lambda version is updated.
+    if (semver.gte(userNodeVersion, '16.0.0')) {
+        return userNodeVersion;
+    }
+    return undefined;
+};
+export const getZisiParameters = ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, userNodeVersion, }) => {
+    const nodeVersion = getLambdaNodeVersion(childEnv, userNodeVersion);
+    const manifest = join(functionsDist, 'manifest.json');
+    const config = mapObject(functionsConfig, (expression, object) => [
+        expression,
+        normalizeFunctionConfig({ buildDir, 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,
+        internalSrcFolder: internalFunctionsSrc,
+    };
+};
+// 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,
+    name: functionConfig.name,
+    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/lib/plugins_core/functions_install/index.js

@@ -0,0 +1,10 @@
+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 {};
+};

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/plugins_core/save_artifacts/index.js

@@ -0,0 +1,33 @@
+import { saveUpdatedConfig } from '../../core/config.js';
+import { shouldDeploy } from '../deploy/index.js';
+const coreStep = async function ({ buildDir, configPath, outputConfigPath, repositoryRoot, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
+    await saveUpdatedConfig({
+        configMutations,
+        buildDir,
+        repositoryRoot,
+        configPath,
+        outputConfigPath,
+        headersPath,
+        redirectsPath,
+        logs,
+        featureFlags,
+        context,
+        branch,
+        debug,
+        saveConfig,
+    });
+    return {};
+};
+// This step and the deploy step must be mutually exclusive, or we end up
+// mutating the config twice.
+const shouldSaveArtifacts = (options) => {
+    return !shouldDeploy(options) && options.saveConfig === true;
+};
+export const saveArtifacts = {
+    event: 'onPostBuild',
+    coreStep,
+    coreStepId: 'save_artifacts',
+    coreStepName: 'Save deploy artifacts',
+    coreStepDescription: () => 'Save deploy artifacts',
+    condition: shouldSaveArtifacts,
+};

package/lib/report/statsd.js

@@ -0,0 +1,56 @@
+import { promisify } from 'util';
+import slugify from '@sindresorhus/slugify';
+import { StatsD } from 'hot-shots';
+export const validateStatsDOptions = function (statsdOpts) {
+    return !!(statsdOpts && statsdOpts.host && statsdOpts.port);
+};
+/**
+ * Start a new StatsD Client and a new UDP socket
+ */
+export const startClient = async function (statsdOpts) {
+    const { host, port } = statsdOpts;
+    return new StatsD({
+        host,
+        port,
+        // This caches the dns resolution for subsequent sends of metrics for this instance
+        // Because we only try to send the metrics on close, this comes only into effect if `bufferFlushInterval` time is exceeded
+        cacheDns: true,
+        // set the maxBufferSize to infinite and the bufferFlushInterval very high, so that we only
+        // send the metrics on close or if more than 10 seconds past by
+        maxBufferSize: Infinity,
+        bufferFlushInterval: 10_000,
+    });
+};
+/**
+ * Close the StatsD Client
+ *
+ * UDP packets are buffered and flushed every 10 seconds and
+ * closing the client forces all buffered metrics to be flushed.
+ */
+export const closeClient = async function (client) {
+    await promisify(client.close.bind(client))();
+};
+/**
+ * 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: '_' });
+};
+/**
+ * Formats and flattens the tags as array
+ * We do this because we might send the same tag with different values `{ tag: ['a', 'b'] }`
+ * which cannot be represented in an flattened object and `hot-shots` also supports tags as array in the format `['tag:a', 'tag:b']`
+ */
+export const formatTags = function (tags) {
+    return Object.entries(tags)
+        .map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return value.map((subValue) => `${key}:${subValue}`);
+        }
+        else {
+            return `${key}:${value}`;
+        }
+    })
+        .flat();
+};

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,62 @@
+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, outputConfigPath, buildDir, repositoryRoot, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, }) {
+    try {
+        const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
+        const childEnvA = setEnvChanges(envChanges, { ...childEnv });
+        const { newEnvChanges = {}, configMutations: newConfigMutations = [], tags, metrics, } = await coreStep({
+            configPath,
+            outputConfigPath,
+            buildDir,
+            repositoryRoot,
+            constants,
+            buildbotServerSocket,
+            events,
+            logs,
+            context,
+            branch,
+            childEnv: childEnvA,
+            netlifyConfig,
+            nodePath,
+            configMutations,
+            headersPath,
+            redirectsPath,
+            featureFlags,
+            debug,
+            systemLog,
+            saveConfig,
+            userNodeVersion,
+        });
+        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,
+            metrics,
+        };
+    }
+    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,44 @@
+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 { saveArtifacts } from '../plugins_core/save_artifacts/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, saveArtifacts];
+};
+// 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);
+    }
+};

package/lib/steps/return.js

@@ -0,0 +1,27 @@
+import { logTimer } from '../log/messages/core.js';
+import { logStepSuccess } from '../log/messages/steps.js';
+import { handleStepError } from './error.js';
+// Retrieve the return value of a step
+export const getStepReturn = function ({ event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName = `${packageName} ${event}`, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, }) {
+    if (newError !== undefined) {
+        return handleStepError({
+            event,
+            newError,
+            childEnv,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            coreStep,
+            netlifyConfig,
+            logs,
+            debug,
+            testOpts,
+        });
+    }
+    if (!quiet) {
+        logStepSuccess(logs);
+        logTimer(logs, durationNs, timerName, systemLog);
+    }
+    return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers, metrics };
+};