@netlify/build 29.0.1-rc → 29.0.2

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

package/lib/steps/run_core_steps.js

@@ -0,0 +1,117 @@
+import { startBuild } from '../core/build.js';
+import { getConfigOpts, loadConfig } from '../core/config.js';
+import { getConstants } from '../core/constants.js';
+import { getSeverity } from '../core/severity.js';
+import { handleBuildError } from '../error/handle.js';
+import { getErrorInfo } from '../error/info.js';
+import { getSystemLogger } from '../log/logger.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 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 };
+};

package/lib/steps/run_step.js

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

package/lib/steps/run_steps.js

@@ -0,0 +1,96 @@
+import pReduce from 'p-reduce';
+import { addErrorInfo } from '../error/info.js';
+import { addStatus } from '../status/add.js';
+import { runStep } from './run_step.js';
+// Run all steps.
+// Each step can change some state: last `error`, environment variables changes,
+// list of `failedPlugins` (that ran `utils.build.failPlugin()`).
+// If an error arises, runs `onError` events.
+// Runs `onEnd` events at the end, whether an error was thrown or not.
+export const runSteps = async function ({ steps, buildbotServerSocket, events, configPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, }) {
+    const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, } = await pReduce(steps, async ({ index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, }, { event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, }) => {
+        const { newIndex = index, newError = error, failedPlugin = [], newEnvChanges = {}, netlifyConfig: netlifyConfigB = netlifyConfigA, configMutations: configMutationsA = configMutations, headersPath: headersPathB = headersPathA, redirectsPath: redirectsPathB = redirectsPathA, newStatus, timers: timersB = timersA, } = await runStep({
+            event,
+            childProcess,
+            packageName,
+            coreStep,
+            coreStepId,
+            coreStepName,
+            coreStepDescription,
+            pluginPackageJson,
+            loadedFrom,
+            origin,
+            condition,
+            configPath,
+            buildDir,
+            repositoryRoot,
+            nodePath,
+            index,
+            childEnv,
+            context,
+            branch,
+            envChanges,
+            constants,
+            steps,
+            buildbotServerSocket,
+            events,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            errorParams,
+            error,
+            failedPlugins,
+            configOpts,
+            netlifyConfig: netlifyConfigA,
+            configMutations,
+            headersPath: headersPathA,
+            redirectsPath: redirectsPathA,
+            logs,
+            debug,
+            systemLog,
+            verbose,
+            saveConfig,
+            timers: timersA,
+            testOpts,
+            featureFlags,
+        });
+        const statusesA = addStatus({ newStatus, statuses, event, packageName, pluginPackageJson });
+        return {
+            index: newIndex,
+            error: newError,
+            failedPlugins: [...failedPlugins, ...failedPlugin],
+            envChanges: { ...envChanges, ...newEnvChanges },
+            netlifyConfig: netlifyConfigB,
+            configMutations: configMutationsA,
+            headersPath: headersPathB,
+            redirectsPath: redirectsPathB,
+            statuses: statusesA,
+            timers: timersB,
+        };
+    }, {
+        index: 0,
+        failedPlugins: [],
+        envChanges: {},
+        netlifyConfig,
+        configMutations: [],
+        headersPath,
+        redirectsPath,
+        statuses: [],
+        timers,
+    });
+    // Instead of throwing any build failure right away, we wait for `onError`,
+    // etc. to complete. This is why we are throwing only now.
+    if (errorA !== undefined) {
+        addErrorInfo(errorA, { statuses: statusesB });
+        throw errorA;
+    }
+    return {
+        stepsCount,
+        netlifyConfig: netlifyConfigC,
+        statuses: statusesB,
+        failedPlugins: failedPluginsA,
+        timers: timersC,
+        configMutations: configMutationsB,
+    };
+};

package/lib/steps/update_config.js

@@ -0,0 +1,66 @@
+import { isDeepStrictEqual } from 'util';
+import pFilter from 'p-filter';
+import { pathExists } from 'path-exists';
+import { resolveUpdatedConfig } from '../core/config.js';
+import { addErrorInfo } from '../error/info.js';
+import { logConfigOnUpdate } from '../log/messages/config.js';
+import { logConfigMutations } from '../log/messages/mutations.js';
+// If `netlifyConfig` was updated or `_redirects` was created, the configuration
+// is updated by calling `@netlify/config` again.
+export const updateNetlifyConfig = async function ({ configOpts, netlifyConfig, headersPath, redirectsPath, configMutations, newConfigMutations, configSideFiles, errorParams, logs, debug, }) {
+    if (!(await shouldUpdateConfig({ newConfigMutations, configSideFiles, headersPath, redirectsPath }))) {
+        return { netlifyConfig, configMutations };
+    }
+    validateConfigMutations(newConfigMutations);
+    logConfigMutations(logs, newConfigMutations, debug);
+    const configMutationsA = [...configMutations, ...newConfigMutations];
+    const { config: netlifyConfigA, headersPath: headersPathA, redirectsPath: redirectsPathA, } = await resolveUpdatedConfig(configOpts, configMutationsA);
+    logConfigOnUpdate({ logs, netlifyConfig: netlifyConfigA, debug });
+    errorParams.netlifyConfig = netlifyConfigA;
+    return {
+        netlifyConfig: netlifyConfigA,
+        configMutations: configMutationsA,
+        headersPath: headersPathA,
+        redirectsPath: redirectsPathA,
+    };
+};
+const shouldUpdateConfig = async function ({ newConfigMutations, configSideFiles, headersPath, redirectsPath }) {
+    return (newConfigMutations.length !== 0 || (await haveConfigSideFilesChanged(configSideFiles, headersPath, redirectsPath)));
+};
+// The configuration mostly depends on `netlify.toml` and UI build settings.
+// However, it also uses some additional optional side files like `_redirects`.
+// Those are often created by the build command. When those are created, we need
+// to update the configuration. We detect this by checking for file existence
+// before and after running plugins and the build command.
+const haveConfigSideFilesChanged = async function (configSideFiles, headersPath, redirectsPath) {
+    const newSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
+    return !isDeepStrictEqual(newSideFiles, configSideFiles);
+};
+// List all the files used for configuration besides `netlify.toml`.
+// This is useful when applying configuration mutations since those files
+// sometimes have higher priority and should therefore be deleted in order to
+// apply any configuration update on `netlify.toml`.
+export const listConfigSideFiles = async function (sideFiles) {
+    const configSideFiles = await pFilter(sideFiles, pathExists);
+    return configSideFiles.sort();
+};
+// Validate each new configuration change
+const validateConfigMutations = function (newConfigMutations) {
+    try {
+        newConfigMutations.forEach(validateConfigMutation);
+    }
+    catch (error) {
+        addErrorInfo(error, { type: 'pluginValidation' });
+        throw error;
+    }
+};
+// Triggered when calling `netlifyConfig.{key} = undefined | null`
+// We do not allow this because the back-end only receives mutations as a
+// `netlify.toml`, i.e. cannot apply property deletions since `undefined` is
+// not serializable in TOML.
+const validateConfigMutation = function ({ value, keysString }) {
+    if (value === undefined || value === null) {
+        throw new Error(`Setting "netlifyConfig.${keysString}" to ${value} is not allowed.
+Please set this property to a specific value instead.`);
+    }
+};

package/lib/telemetry/main.js

@@ -0,0 +1,97 @@
+import { platform } from 'process';
+import got from 'got';
+import osName from 'os-name';
+import { addErrorInfo } from '../error/info.js';
+import { roundTimerToMillisecs } from '../time/measure.js';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+const DEFAULT_TELEMETRY_TIMEOUT = 1200;
+const DEFAULT_TELEMETRY_CONFIG = {
+    origin: 'https://api.segment.io/v1',
+    writeKey: 'dWhlM1lYSlpNd1k5Uk9rcjFra2JSOEoybnRjZjl0YTI6',
+    timeout: DEFAULT_TELEMETRY_TIMEOUT,
+};
+// Send telemetry request when build completes
+export const trackBuildComplete = async function ({ deployId, buildId, status, stepsCount, pluginsOptions, durationNs, siteInfo, telemetry, userNodeVersion, framework, testOpts: { telemetryOrigin = DEFAULT_TELEMETRY_CONFIG.origin, telemetryTimeout = DEFAULT_TELEMETRY_CONFIG.timeout }, }) {
+    if (!telemetry) {
+        return;
+    }
+    try {
+        const payload = getPayload({
+            deployId,
+            buildId,
+            status,
+            stepsCount,
+            pluginsOptions,
+            durationNs,
+            siteInfo,
+            userNodeVersion,
+            framework,
+        });
+        await track({
+            payload,
+            config: { ...DEFAULT_TELEMETRY_CONFIG, origin: telemetryOrigin, timeout: telemetryTimeout },
+        });
+    }
+    catch (error) {
+        addErrorInfo(error, { type: 'telemetry' });
+        throw error;
+    }
+};
+// Send track HTTP request to telemetry.
+const track = async function ({ payload, config: { origin, writeKey, timeout } }) {
+    const url = `${origin}/track`;
+    await got.post(url, {
+        json: payload,
+        timeout,
+        retry: 0,
+        headers: { Authorization: `Basic ${writeKey}` },
+    });
+};
+// Retrieve telemetry information
+// siteInfo can be empty if the build fails during the get config step
+const getPayload = function ({ deployId, buildId, status, stepsCount, pluginsOptions, durationNs, userNodeVersion, siteInfo = {}, framework, }) {
+    return {
+        userId: 'buildbot_user',
+        event: 'build:ci_build_process_completed',
+        timestamp: Date.now(),
+        properties: {
+            deployId,
+            buildId,
+            status,
+            steps: stepsCount,
+            buildVersion: ROOT_PACKAGE_JSON.version,
+            // We're passing the node version set by the buildbot/user which will run the `build.command` and
+            // the `package.json`/locally defined plugins
+            nodeVersion: userNodeVersion,
+            osPlatform: OS_TYPES[platform],
+            osName: osName(),
+            framework,
+            siteId: siteInfo.id,
+            ...(pluginsOptions !== undefined && {
+                plugins: pluginsOptions.map(getPlugin),
+                pluginCount: pluginsOptions.length,
+            }),
+            ...(durationNs !== undefined && { duration: roundTimerToMillisecs(durationNs) }),
+        },
+    };
+};
+const OS_TYPES = {
+    linux: 'Linux',
+    darwin: 'MacOS',
+    win32: 'Windows',
+    android: 'Android',
+    sunos: 'SunOS',
+    aix: 'AIX',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+};
+const getPlugin = function ({ packageName, origin, loadedFrom, nodeVersion, pinnedVersion, pluginPackageJson: { version } = {}, }) {
+    const installType = getInstallType(origin, loadedFrom);
+    return { name: packageName, installType, nodeVersion, pinnedVersion, version };
+};
+const getInstallType = function (origin, loadedFrom) {
+    if (loadedFrom === 'auto_install') {
+        return origin === 'ui' ? 'ui' : 'netlify_toml';
+    }
+    return loadedFrom;
+};