@netlify/build 0.4.48 → 1.0.0-dl-test

package/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// This is a workaround for npm issue: https://github.com/npm/cli/issues/2632
+
+import './lib/core/bin.js'

package/lib/core/bin.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import process from 'process';
+import filterObj from 'filter-obj';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { normalizeCliFeatureFlags } from './feature_flags.js';
+import { FLAGS } from './flags.js';
+import build from './main.js';
+import { FALLBACK_SEVERITY_ENTRY } from './severity.js';
+// CLI entry point.
+// Before adding logic to this file, please consider adding it to the main
+// programmatic command instead, so that the new logic is available when run
+// programmatically as well. This file should only contain logic that makes
+// sense only in CLI, such as CLI flags parsing and exit code.
+const runCli = async function () {
+    const flags = parseFlags();
+    const flagsA = filterObj(flags, isUserFlag);
+    const state = { done: false };
+    process.on('exit', onExit.bind(undefined, state));
+    const { severityCode, logs } = await build(flagsA);
+    printLogs(logs);
+    process.exitCode = severityCode;
+    state.done = true;
+};
+const parseFlags = function () {
+    const { featureFlags: cliFeatureFlags = '', ...flags } = yargs(hideBin(process.argv))
+        .options(FLAGS)
+        .usage(USAGE)
+        .parse();
+    const featureFlags = normalizeCliFeatureFlags(cliFeatureFlags);
+    return { ...flags, featureFlags };
+};
+const USAGE = `netlify-build [OPTIONS...]
+
+Run Netlify Build system locally.
+
+Options can also be specified as environment variables prefixed with
+NETLIFY_BUILD_. For example the environment variable NETLIFY_BUILD_DRY=true can
+be used instead of the CLI flag --dry.`;
+// Remove `yargs`-specific options, shortcuts, dash-cased and aliases
+const isUserFlag = function (key, value) {
+    return value !== undefined && !INTERNAL_KEYS.has(key) && key.length !== 1 && !key.includes('-');
+};
+const INTERNAL_KEYS = new Set(['help', 'version', '_', '$0', 'dryRun']);
+// Used mostly for testing
+const printLogs = function (logs) {
+    if (logs === undefined) {
+        return;
+    }
+    const allLogs = [logs.stdout.join('\n'), logs.stderr.join('\n')].filter(Boolean).join('\n\n');
+    console.log(allLogs);
+};
+// In theory, the main process should not exit until the main `build()` function
+// has completed. In practice, this might happen due to bugs.
+// Making the exit code not 0 in that case ensures the caller knows that the
+// build has completed when the exit code is 0. This `exit` event handlers
+// guarantees this.
+const onExit = function ({ done }, exitCode) {
+    if (done || exitCode !== 0) {
+        return;
+    }
+    const [, processName] = process.argv;
+    console.log(`${processName} exited with exit code ${exitCode} without finishing the build.`);
+    process.exitCode = FALLBACK_SEVERITY_ENTRY.severityCode;
+};
+runCli();

package/lib/core/build.js

@@ -0,0 +1,392 @@
+import { supportedRuntimes } from '@netlify/framework-info';
+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 { loadPlugins } from '../plugins/load.js';
+import { getPluginsOptions } from '../plugins/options.js';
+import { pinPlugins } from '../plugins/pinned_version.js';
+import { startPlugins, stopPlugins } from '../plugins/spawn.js';
+import { addCorePlugins } from '../plugins_core/add.js';
+import { reportStatuses } from '../status/report.js';
+import { getDevSteps, getSteps } from '../steps/get.js';
+import { runSteps } from '../steps/run_steps.js';
+import { initTimers, measureDuration } from '../time/main.js';
+import { getConfigOpts, loadConfig } from './config.js';
+import { getConstants } from './constants.js';
+import { doDryRun } from './dry.js';
+import { warnOnLingeringProcesses } from './lingering.js';
+import { warnOnMissingSideFiles } from './missing_side_file.js';
+import { normalizeFlags } from './normalize_flags.js';
+// Performed on build start. Must be kept small and unlikely to fail since it
+// does not have proper error handling. Error handling relies on `errorMonitor`
+// being built, which relies itself on flags being normalized.
+export const startBuild = function (flags) {
+    const timers = initTimers();
+    const logs = getBufferLogs(flags);
+    if (!flags.quiet) {
+        logBuildStart(logs);
+    }
+    const { bugsnagKey, ...flagsA } = normalizeFlags(flags, logs);
+    const errorMonitor = startErrorMonitor({ flags: flagsA, logs, bugsnagKey });
+    return { ...flagsA, errorMonitor, logs, timers };
+};
+const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cachedConfigPath, outputConfigPath, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, env: envOpt, debug, systemLogFile, verbose, nodePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, dry, mode, offline, deployId, buildId, testOpts, errorMonitor, errorParams, logs, timers, buildbotServerSocket, sendStatus, saveConfig, featureFlags, timeline, devCommand, quiet, framework, }) {
+    const configOpts = getConfigOpts({
+        config,
+        defaultConfig,
+        cwd,
+        repositoryRoot,
+        apiHost,
+        token,
+        siteId,
+        context,
+        branch,
+        baseRelDir,
+        envOpt,
+        mode,
+        offline,
+        deployId,
+        buildId,
+        testOpts,
+        featureFlags,
+    });
+    const { netlifyConfig, configPath, headersPath, redirectsPath, buildDir, repositoryRoot: repositoryRootA, packageJson, userNodeVersion, childEnv, context: contextA, branch: branchA, token: tokenA, api, siteInfo, timers: timersA, } = await loadConfig({
+        configOpts,
+        cachedConfig,
+        cachedConfigPath,
+        envOpt,
+        debug,
+        logs,
+        nodePath,
+        timers,
+        quiet,
+    });
+    if (featureFlags.build_automatic_runtime && framework) {
+        const runtime = supportedRuntimes[framework];
+        if (runtime !== undefined) {
+            const skip = childEnv[runtime.skipFlag] === 'true';
+            const installed = netlifyConfig.plugins.some((plugin) => plugin.package === runtime.package);
+            if (!installed && !skip) {
+                netlifyConfig.plugins.push({ package: runtime.package });
+            }
+        }
+    }
+    const constants = await getConstants({
+        configPath,
+        buildDir,
+        functionsDistDir,
+        edgeFunctionsDistDir,
+        cacheDir,
+        netlifyConfig,
+        siteInfo,
+        apiHost,
+        token: tokenA,
+        mode,
+        testOpts,
+    });
+    const systemLog = getSystemLogger(logs, debug, systemLogFile);
+    const pluginsOptions = addCorePlugins({ netlifyConfig, constants });
+    // `errorParams` is purposely stateful
+    Object.assign(errorParams, { netlifyConfig, pluginsOptions, siteInfo, childEnv, userNodeVersion });
+    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, metrics, } = await runAndReportBuild({
+        pluginsOptions,
+        netlifyConfig,
+        configOpts,
+        siteInfo,
+        configPath,
+        outputConfigPath,
+        headersPath,
+        redirectsPath,
+        buildDir,
+        repositoryRoot: repositoryRootA,
+        nodePath,
+        packageJson,
+        userNodeVersion,
+        childEnv,
+        context: contextA,
+        branch: branchA,
+        dry,
+        mode,
+        api,
+        errorMonitor,
+        deployId,
+        errorParams,
+        logs,
+        debug,
+        systemLog,
+        verbose,
+        timers: timersA,
+        sendStatus,
+        saveConfig,
+        testOpts,
+        buildbotServerSocket,
+        constants,
+        featureFlags,
+        timeline,
+        devCommand,
+        quiet,
+    });
+    return {
+        pluginsOptions: pluginsOptionsA,
+        netlifyConfig: netlifyConfigA,
+        siteInfo,
+        userNodeVersion,
+        stepsCount,
+        timers: timersB,
+        configMutations,
+        metrics,
+    };
+};
+export const execBuild = measureDuration(tExecBuild, 'total', { parentTag: 'build_site' });
+// Runs a build then report any plugin statuses
+export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, }) {
+    try {
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, } = await initAndRunBuild({
+            pluginsOptions,
+            netlifyConfig,
+            configOpts,
+            siteInfo,
+            configPath,
+            outputConfigPath,
+            headersPath,
+            redirectsPath,
+            buildDir,
+            repositoryRoot,
+            nodePath,
+            packageJson,
+            userNodeVersion,
+            childEnv,
+            context,
+            branch,
+            dry,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            errorParams,
+            logs,
+            debug,
+            systemLog,
+            verbose,
+            timers,
+            sendStatus,
+            saveConfig,
+            testOpts,
+            buildbotServerSocket,
+            constants,
+            featureFlags,
+            timeline,
+            devCommand,
+            quiet,
+        });
+        await Promise.all([
+            reportStatuses({
+                statuses,
+                childEnv,
+                api,
+                mode,
+                pluginsOptions: pluginsOptionsA,
+                netlifyConfig: netlifyConfigA,
+                errorMonitor,
+                deployId,
+                logs,
+                debug,
+                sendStatus,
+                testOpts,
+            }),
+            pinPlugins({
+                pluginsOptions: pluginsOptionsA,
+                failedPlugins,
+                api,
+                siteInfo,
+                childEnv,
+                mode,
+                netlifyConfig: netlifyConfigA,
+                errorMonitor,
+                logs,
+                debug,
+                testOpts,
+                sendStatus,
+            }),
+        ]);
+        return {
+            pluginsOptions: pluginsOptionsA,
+            netlifyConfig: netlifyConfigA,
+            stepsCount,
+            timers: timersA,
+            configMutations,
+            metrics,
+        };
+    }
+    catch (error) {
+        const [{ statuses }] = getErrorInfo(error);
+        await reportStatuses({
+            statuses,
+            childEnv,
+            api,
+            mode,
+            pluginsOptions,
+            netlifyConfig,
+            errorMonitor,
+            deployId,
+            logs,
+            debug,
+            sendStatus,
+            testOpts,
+        });
+        throw error;
+    }
+};
+// Initialize plugin processes then runs a build
+const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, sendStatus, saveConfig, timers, testOpts, buildbotServerSocket, constants, featureFlags, timeline, devCommand, quiet, }) {
+    const { pluginsOptions: pluginsOptionsA, timers: timersA } = await getPluginsOptions({
+        pluginsOptions,
+        netlifyConfig,
+        siteInfo,
+        buildDir,
+        nodePath,
+        packageJson,
+        userNodeVersion,
+        mode,
+        api,
+        logs,
+        debug,
+        sendStatus,
+        timers,
+        testOpts,
+        featureFlags,
+    });
+    errorParams.pluginsOptions = pluginsOptionsA;
+    const { childProcesses, timers: timersB } = await startPlugins({
+        pluginsOptions: pluginsOptionsA,
+        buildDir,
+        childEnv,
+        logs,
+        debug,
+        timers: timersA,
+        featureFlags,
+        quiet,
+    });
+    try {
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, } = await runBuild({
+            childProcesses,
+            pluginsOptions: pluginsOptionsA,
+            netlifyConfig,
+            configOpts,
+            packageJson,
+            configPath,
+            outputConfigPath,
+            userNodeVersion,
+            headersPath,
+            redirectsPath,
+            buildDir,
+            repositoryRoot,
+            nodePath,
+            childEnv,
+            context,
+            branch,
+            dry,
+            buildbotServerSocket,
+            constants,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            errorParams,
+            logs,
+            debug,
+            systemLog,
+            verbose,
+            saveConfig,
+            timers: timersB,
+            testOpts,
+            featureFlags,
+            timeline,
+            devCommand,
+            quiet,
+        });
+        await Promise.all([
+            warnOnMissingSideFiles({ buildDir, netlifyConfig: netlifyConfigA, logs }),
+            warnOnLingeringProcesses({ mode, logs, testOpts }),
+        ]);
+        return {
+            stepsCount,
+            netlifyConfig: netlifyConfigA,
+            statuses,
+            pluginsOptions: pluginsOptionsA,
+            failedPlugins,
+            timers: timersC,
+            configMutations,
+            metrics,
+        };
+    }
+    finally {
+        // Terminate the child processes of plugins so that they don't linger after
+        // the build is finished. The exception is when running in the dev timeline
+        // since those are long-running events by nature.
+        if (timeline !== 'dev') {
+            stopPlugins(childProcesses);
+        }
+    }
+};
+// Load plugin main files, retrieve their event handlers then runs them,
+// together with the build command
+const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig, configOpts, packageJson, configPath, outputConfigPath, userNodeVersion, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, dry, buildbotServerSocket, constants, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, timeline, devCommand, quiet, }) {
+    const { pluginsSteps, timers: timersA } = await loadPlugins({
+        pluginsOptions,
+        childProcesses,
+        packageJson,
+        timers,
+        logs,
+        debug,
+        verbose,
+    });
+    const { steps, events } = timeline === 'dev' ? getDevSteps(devCommand, pluginsSteps) : getSteps(pluginsSteps);
+    if (dry) {
+        await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs });
+        return { netlifyConfig };
+    }
+    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, } = await runSteps({
+        steps,
+        buildbotServerSocket,
+        events,
+        configPath,
+        outputConfigPath,
+        headersPath,
+        redirectsPath,
+        buildDir,
+        repositoryRoot,
+        nodePath,
+        childEnv,
+        context,
+        branch,
+        constants,
+        mode,
+        api,
+        errorMonitor,
+        deployId,
+        errorParams,
+        netlifyConfig,
+        configOpts,
+        logs,
+        debug,
+        systemLog,
+        verbose,
+        saveConfig,
+        timers: timersA,
+        testOpts,
+        featureFlags,
+        quiet,
+        userNodeVersion,
+    });
+    return {
+        stepsCount,
+        netlifyConfig: netlifyConfigA,
+        statuses,
+        failedPlugins,
+        timers: timersB,
+        configMutations,
+        metrics,
+    };
+};

package/lib/core/config.js

@@ -0,0 +1,124 @@
+import { resolveConfig, updateConfig, restoreConfig } from '@netlify/config';
+import mapObj from 'map-obj';
+import { getChildEnv } from '../env/main.js';
+import { addApiErrorHandlers } from '../error/api.js';
+import { changeErrorType } from '../error/info.js';
+import { logBuildDir, logConfigPath, logConfig, logContext } from '../log/messages/config.js';
+import { logConfigOnUpload, logHeadersOnUpload, logRedirectsOnUpload } from '../log/messages/mutations.js';
+import { measureDuration } from '../time/main.js';
+import { getPackageJson } from '../utils/package.js';
+import { getUserNodeVersion } from './user_node_version.js';
+// Retrieve immutable options passed to `@netlify/config`.
+// This does not include options which might change during the course of the
+// build:
+//  - `cachedConfig` and `cachedConfigPath` are only used at the beginning of
+//    the build
+//  - If plugins change the configuration, `configMutations` is used instead
+// In both cases, almost all options should remain the same.
+export const getConfigOpts = function ({ config, defaultConfig, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, envOpt, mode, offline, deployId, buildId, testOpts, featureFlags, }) {
+    return {
+        config,
+        defaultConfig,
+        cwd,
+        repositoryRoot,
+        context,
+        branch,
+        baseRelDir,
+        host: apiHost,
+        token,
+        siteId,
+        deployId,
+        buildId,
+        mode,
+        offline,
+        env: envOpt,
+        testOpts,
+        featureFlags,
+    };
+};
+// Retrieve configuration object
+const tLoadConfig = async function ({ configOpts, cachedConfig, cachedConfigPath, envOpt, debug, logs, nodePath, quiet, }) {
+    const { configPath, headersPath, redirectsPath, buildDir, repositoryRoot, config: netlifyConfig, context: contextA, branch: branchA, token: tokenA, api, siteInfo, env, } = await resolveInitialConfig(configOpts, cachedConfig, cachedConfigPath);
+    if (!quiet) {
+        logConfigInfo({ logs, configPath, buildDir, netlifyConfig, context: contextA, debug });
+    }
+    const apiA = addApiErrorHandlers(api);
+    const envValues = mapObj(env, (key, { value }) => [key, value]);
+    const childEnv = getChildEnv({ envOpt, env: envValues });
+    const [{ packageJson }, userNodeVersion] = await Promise.all([getPackageJson(buildDir), getUserNodeVersion(nodePath)]);
+    return {
+        netlifyConfig,
+        configPath,
+        headersPath,
+        redirectsPath,
+        buildDir,
+        repositoryRoot,
+        packageJson,
+        userNodeVersion,
+        childEnv,
+        context: contextA,
+        branch: branchA,
+        token: tokenA,
+        api: apiA,
+        siteInfo,
+    };
+};
+export const loadConfig = measureDuration(tLoadConfig, 'resolve_config');
+// Retrieve initial configuration.
+// In the buildbot and CLI, we re-use the already parsed `@netlify/config`
+// return value which is passed as `cachedConfig`/`cachedConfigPath`.
+const resolveInitialConfig = async function (configOpts, cachedConfig, cachedConfigPath) {
+    return await resolveConfig({ ...configOpts, cachedConfig, cachedConfigPath });
+};
+const logConfigInfo = function ({ logs, configPath, buildDir, netlifyConfig, context, debug }) {
+    logBuildDir(logs, buildDir);
+    logConfigPath(logs, configPath);
+    logConfig({ logs, netlifyConfig, debug });
+    logContext(logs, context);
+};
+// Retrieve the configuration after it's been changed.
+// This ensures any configuration changes done by plugins is validated and
+// normalized.
+// We use `debug: false` to avoid any debug logs. Otherwise, every configuration
+// change would create debug logs which would be too verbose.
+// Errors are propagated and assigned to the specific plugin or core step
+// which changed the configuration.
+export const resolveUpdatedConfig = async function (configOpts, configMutations) {
+    try {
+        return await resolveConfig({ ...configOpts, configMutations, debug: false });
+    }
+    catch (error) {
+        changeErrorType(error, 'resolveConfig', 'pluginValidation');
+        throw error;
+    }
+};
+// If the configuration was changed, persist it to `netlify.toml`.
+// If `netlify.toml` does not exist, create it inside repository root.
+// This is only done when `saveConfig` is `true`. This allows performing this
+// in the buildbot but not in local builds, since only the latter run in a
+// container, and we want to avoid saving files on local machines.
+export const saveUpdatedConfig = async function ({ configMutations, buildDir, repositoryRoot, configPath = `${repositoryRoot}/netlify.toml`, outputConfigPath = configPath, headersPath, redirectsPath, logs, featureFlags, context, branch, debug, saveConfig, }) {
+    if (!saveConfig) {
+        return;
+    }
+    await updateConfig(configMutations, {
+        buildDir,
+        configPath,
+        outputConfigPath,
+        headersPath,
+        redirectsPath,
+        context,
+        branch,
+        logs,
+        featureFlags,
+    });
+    await logConfigOnUpload({ logs, configPath, debug });
+    await logHeadersOnUpload({ logs, headersPath, debug });
+    await logRedirectsOnUpload({ logs, redirectsPath, debug });
+};
+export const restoreUpdatedConfig = async function ({ configMutations, buildDir, repositoryRoot, configPath = `${repositoryRoot}/netlify.toml`, headersPath, redirectsPath, saveConfig, }) {
+    if (!saveConfig) {
+        return;
+    }
+    await restoreConfig(configMutations, { buildDir, configPath, headersPath, redirectsPath });
+};