@netlify/build 28.0.1-beta → 28.1.0-framework-version-detection

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/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,57 @@
+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,
+        };
+    }
+    catch (newError) {
+        if (!isBuildError(newError)) {
+            addErrorInfo(newError, { type: 'coreStep', location: { coreStepName } });
+        }
+        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);
+    }
+};

package/lib/steps/return.js

@@ -0,0 +1,25 @@
+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, }) {
+    if (newError !== undefined) {
+        return handleStepError({
+            event,
+            newError,
+            childEnv,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            coreStep,
+            netlifyConfig,
+            logs,
+            debug,
+            testOpts,
+        });
+    }
+    logStepSuccess(logs);
+    logTimer(logs, durationNs, timerName);
+    return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers };
+};

package/lib/steps/run_core_steps.js

@@ -0,0 +1,126 @@
+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.
+ */
+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,
+    });
+    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 };
+};