@netlify/build 29.0.1-rc → 29.0.2

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,356 @@
+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);
+    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, 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, }) {
+    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,
+    });
+    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, } = await runAndReportBuild({
+        pluginsOptions,
+        netlifyConfig,
+        configOpts,
+        siteInfo,
+        configPath,
+        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,
+    });
+    return {
+        pluginsOptions: pluginsOptionsA,
+        netlifyConfig: netlifyConfigA,
+        siteInfo,
+        userNodeVersion,
+        stepsCount,
+        timers: timersB,
+        configMutations,
+    };
+};
+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, 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, }) {
+    try {
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, } = await initAndRunBuild({
+            pluginsOptions,
+            netlifyConfig,
+            configOpts,
+            siteInfo,
+            configPath,
+            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,
+        });
+        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,
+        };
+    }
+    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, 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, }) {
+    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,
+    });
+    try {
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, } = await runBuild({
+            childProcesses,
+            pluginsOptions: pluginsOptionsA,
+            netlifyConfig,
+            configOpts,
+            packageJson,
+            configPath,
+            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,
+        });
+        await Promise.all([
+            warnOnMissingSideFiles({ buildDir, netlifyConfig: netlifyConfigA, logs }),
+            warnOnLingeringProcesses({ mode, logs, testOpts }),
+        ]);
+        return {
+            stepsCount,
+            netlifyConfig: netlifyConfigA,
+            statuses,
+            pluginsOptions: pluginsOptionsA,
+            failedPlugins,
+            timers: timersC,
+            configMutations,
+        };
+    }
+    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, 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, }) {
+    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, } = await runSteps({
+        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: timersA,
+        testOpts,
+        featureFlags,
+    });
+    return { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations };
+};

package/lib/core/config.js

@@ -0,0 +1,121 @@
+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 }) {
+    const { configPath, headersPath, redirectsPath, buildDir, repositoryRoot, config: netlifyConfig, context: contextA, branch: branchA, token: tokenA, api, siteInfo, env, } = await resolveInitialConfig(configOpts, cachedConfig, cachedConfigPath);
+    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`, headersPath, redirectsPath, logs, featureFlags, context, branch, debug, saveConfig, }) {
+    if (!saveConfig) {
+        return;
+    }
+    await updateConfig(configMutations, {
+        buildDir,
+        configPath,
+        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 });
+};

package/lib/core/constants.js

@@ -0,0 +1,116 @@
+import { relative, normalize } from 'path';
+import { getCacheDir } from '@netlify/cache-utils';
+import mapObj from 'map-obj';
+import { pathExists } from 'path-exists';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+// Retrieve constants passed to plugins
+export const getConstants = async function ({ configPath, buildDir, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }) {
+    const isLocal = mode !== 'buildbot';
+    const normalizedCacheDir = getCacheDir({ cacheDir, cwd: buildDir });
+    const constants = {
+        // Path to the Netlify configuration file
+        CONFIG_PATH: configPath,
+        // The directory where built serverless functions are placed before deployment
+        FUNCTIONS_DIST: functionsDistDir,
+        // The directory where built Edge Functions are placed before deployment
+        EDGE_FUNCTIONS_DIST: edgeFunctionsDistDir,
+        // Path to the Netlify build cache folder
+        CACHE_DIR: normalizedCacheDir,
+        // Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
+        IS_LOCAL: isLocal,
+        // The version of Netlify Build
+        NETLIFY_BUILD_VERSION: ROOT_PACKAGE_JSON.version,
+        // The Netlify Site ID
+        SITE_ID: siteId,
+        // The Netlify API access token
+        NETLIFY_API_TOKEN: token,
+        // The Netlify API host
+        NETLIFY_API_HOST: apiHost,
+        // The directory where internal functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_FUNCTIONS_SRC}`,
+        // The directory where internal Edge Functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_EDGE_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_EDGE_FUNCTIONS_SRC}`,
+    };
+    const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
+    return constantsA;
+};
+const INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions';
+const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal';
+// Retrieve constants which might change during the build if a plugin modifies
+// `netlifyConfig` or creates some default directories.
+// Unlike readonly constants, this is called again before each build step.
+export const addMutableConstants = async function ({ constants, buildDir, netlifyConfig: { build: { publish, edge_functions: edgeFunctions }, functionsDirectory, }, }) {
+    const constantsA = {
+        ...constants,
+        // Directory that contains the deploy-ready HTML files and assets generated by the build
+        PUBLISH_DIR: publish,
+        // The directory where function source code lives
+        FUNCTIONS_SRC: functionsDirectory,
+        // The directory where Edge Functions source code lives
+        EDGE_FUNCTIONS_SRC: edgeFunctions,
+    };
+    const constantsB = await addDefaultConstants(constantsA, buildDir);
+    const constantsC = normalizeConstantsPaths(constantsB, buildDir);
+    return constantsC;
+};
+// Some `constants` have a default value when a specific file exists.
+// Those default values are assigned by `@netlify/config`. However, the build
+// command or plugins might create those specific files, in which case, the
+// related `constant` should be updated, unless the user has explicitly
+// configured it.
+const addDefaultConstants = async function (constants, buildDir) {
+    const newConstants = await Promise.all(DEFAULT_PATHS.map(({ constantName, defaultPath }) => addDefaultConstant({ constants, constantName, defaultPath, buildDir })));
+    return Object.assign({}, constants, ...newConstants);
+};
+// The current directory is the build directory, which is correct, so we don't
+// need to resolve paths
+const DEFAULT_PATHS = [
+    // @todo Remove once we drop support for the legacy default functions directory.
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify-automatic-functions' },
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify/functions' },
+    { constantName: 'EDGE_FUNCTIONS_SRC', defaultPath: 'netlify/edge-functions' },
+];
+const addDefaultConstant = async function ({ constants, constantName, defaultPath, buildDir }) {
+    // Configuration paths are relative to the build directory.
+    if (!isEmptyValue(constants[constantName]) || !(await pathExists(`${buildDir}/${defaultPath}`))) {
+        return {};
+    }
+    // However, the plugin child process' current directory is the build directory,
+    // so we can pass the relative path instead of the resolved absolute path.
+    return { [constantName]: defaultPath };
+};
+const normalizeConstantsPaths = function (constants, buildDir) {
+    return mapObj(constants, (key, path) => [key, normalizePath(path, buildDir, key)]);
+};
+// The current directory is `buildDir`. Most constants are inside this `buildDir`.
+// Instead of passing absolute paths, we pass paths relative to `buildDir`, so
+// that logs are less verbose.
+const normalizePath = function (path, buildDir, key) {
+    if (isEmptyValue(path) || !CONSTANT_PATHS.has(key)) {
+        return path;
+    }
+    const pathA = normalize(path);
+    if (pathA === buildDir) {
+        return '.';
+    }
+    if (pathA.startsWith(buildDir)) {
+        return relative(buildDir, pathA);
+    }
+    return pathA;
+};
+const isEmptyValue = function (path) {
+    return path === undefined || path === '';
+};
+const CONSTANT_PATHS = new Set([
+    'CONFIG_PATH',
+    'PUBLISH_DIR',
+    'FUNCTIONS_SRC',
+    'FUNCTIONS_DIST',
+    'INTERNAL_EDGE_FUNCTIONS_SRC',
+    'INTERNAL_FUNCTIONS_SRC',
+    'EDGE_FUNCTIONS_DIST',
+    'EDGE_FUNCTIONS_SRC',
+    'CACHE_DIR',
+]);

package/lib/core/dev.js

@@ -0,0 +1,27 @@
+import { handleBuildError } from '../error/handle.js';
+import { execBuild, startBuild } from './build.js';
+import { getSeverity } from './severity.js';
+export const startDev = async (devCommand, flags = {}) => {
+    const { errorMonitor, mode, logs, debug, testOpts, ...normalizedFlags } = startBuild(flags);
+    const errorParams = { errorMonitor, mode, logs, debug, testOpts };
+    try {
+        const { netlifyConfig: netlifyConfigA, configMutations } = await execBuild({
+            ...normalizedFlags,
+            errorMonitor,
+            errorParams,
+            mode,
+            logs,
+            debug,
+            testOpts,
+            timeline: 'dev',
+            devCommand,
+        });
+        const { success, severityCode } = getSeverity('success');
+        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+    }
+    catch (error) {
+        const { severity, message, stack } = await handleBuildError(error, errorParams);
+        const { success, severityCode } = getSeverity(severity);
+        return { success, severityCode, logs, error: { message, stack } };
+    }
+};