@netlify/build 27.20.4 → 27.20.5

package/lib/core/main.js

@@ -1,14 +1,11 @@
-import { handleBuildError } from '../error/handle.js'
-import { logTimer, logBuildSuccess } from '../log/messages/core.js'
-import { trackBuildComplete } from '../telemetry/main.js'
-import { reportTimers } from '../time/report.js'
-
-import { execBuild, startBuild } from './build.js'
-import { getSeverity } from './severity.js'
-
-export { startDev } from './dev.js'
-export { runCoreSteps } from '../steps/run_core_steps.js'
-
+import { handleBuildError } from '../error/handle.js';
+import { logTimer, logBuildSuccess } from '../log/messages/core.js';
+import { trackBuildComplete } from '../telemetry/main.js';
+import { reportTimers } from '../time/report.js';
+import { execBuild, startBuild } from './build.js';
+import { getSeverity } from './severity.js';
+export { startDev } from './dev.js';
+export { runCoreSteps } from '../steps/run_core_steps.js';
 /**
  * Main entry point of Netlify Build.
  * Runs a builds and returns whether it succeeded or not.
@@ -34,132 +31,93 @@ export { runCoreSteps } from '../steps/run_core_steps.js'
  * @returns {string[]} buildResult.logs - When using the `buffer` option, all log messages
  */
 export default async function buildSite(flags = {}) {
-  const {
-    errorMonitor,
-    framework,
-    mode,
-    logs,
-    debug,
-    systemLogFile,
-    testOpts,
-    statsdOpts,
-    dry,
-    telemetry,
-    buildId,
-    deployId,
-    ...flagsA
-  } = startBuild(flags)
-  const errorParams = { errorMonitor, mode, logs, debug, testOpts }
-
-  try {
-    const {
-      pluginsOptions,
-      netlifyConfig: netlifyConfigA,
-      siteInfo,
-      userNodeVersion,
-      stepsCount,
-      timers,
-      durationNs,
-      configMutations,
-    } = await execBuild({
-      ...flagsA,
-      buildId,
-      systemLogFile,
-      deployId,
-      dry,
-      errorMonitor,
-      mode,
-      logs,
-      debug,
-      testOpts,
-      errorParams,
-    })
-    await handleBuildSuccess({
-      framework,
-      dry,
-      logs,
-      timers,
-      durationNs,
-      statsdOpts,
-    })
-    const { success, severityCode, status } = getSeverity('success')
-    await telemetryReport({
-      buildId,
-      deployId,
-      status,
-      stepsCount,
-      pluginsOptions,
-      durationNs,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-      errorParams,
-    })
-    return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations }
-  } catch (error) {
-    const { severity } = await handleBuildError(error, errorParams)
-    const { pluginsOptions, siteInfo, userNodeVersion } = errorParams
-    const { success, severityCode, status } = getSeverity(severity)
-    await telemetryReport({
-      buildId,
-      deployId,
-      status,
-      pluginsOptions,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-      errorParams,
-    })
-    return { success, severityCode, logs }
-  }
+    const { errorMonitor, framework, mode, logs, debug, systemLogFile, testOpts, statsdOpts, dry, telemetry, buildId, deployId, ...flagsA } = startBuild(flags);
+    const errorParams = { errorMonitor, mode, logs, debug, testOpts };
+    try {
+        const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, } = await execBuild({
+            ...flagsA,
+            buildId,
+            systemLogFile,
+            deployId,
+            dry,
+            errorMonitor,
+            mode,
+            logs,
+            debug,
+            testOpts,
+            errorParams,
+        });
+        await handleBuildSuccess({
+            framework,
+            dry,
+            logs,
+            timers,
+            durationNs,
+            statsdOpts,
+        });
+        const { success, severityCode, status } = getSeverity('success');
+        await telemetryReport({
+            buildId,
+            deployId,
+            status,
+            stepsCount,
+            pluginsOptions,
+            durationNs,
+            siteInfo,
+            telemetry,
+            userNodeVersion,
+            framework,
+            testOpts,
+            errorParams,
+        });
+        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+    }
+    catch (error) {
+        const { severity } = await handleBuildError(error, errorParams);
+        const { pluginsOptions, siteInfo, userNodeVersion } = errorParams;
+        const { success, severityCode, status } = getSeverity(severity);
+        await telemetryReport({
+            buildId,
+            deployId,
+            status,
+            pluginsOptions,
+            siteInfo,
+            telemetry,
+            userNodeVersion,
+            framework,
+            testOpts,
+            errorParams,
+        });
+        return { success, severityCode, logs };
+    }
 }
-
 // Logs and reports that a build successfully ended
 const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts }) {
-  if (dry) {
-    return
-  }
-
-  logBuildSuccess(logs)
-
-  logTimer(logs, durationNs, 'Netlify Build')
-  await reportTimers({ timers, statsdOpts, framework })
-}
-
+    if (dry) {
+        return;
+    }
+    logBuildSuccess(logs);
+    logTimer(logs, durationNs, 'Netlify Build');
+    await reportTimers({ timers, statsdOpts, framework });
+};
 // Handles the calls and errors of telemetry reports
-const telemetryReport = async function ({
-  deployId,
-  buildId,
-  status,
-  stepsCount,
-  pluginsOptions,
-  durationNs,
-  siteInfo,
-  telemetry,
-  userNodeVersion,
-  framework,
-  testOpts,
-  errorParams,
-}) {
-  try {
-    await trackBuildComplete({
-      deployId,
-      buildId,
-      status,
-      stepsCount,
-      pluginsOptions,
-      durationNs,
-      siteInfo,
-      telemetry,
-      userNodeVersion,
-      framework,
-      testOpts,
-    })
-  } catch (error) {
-    await handleBuildError(error, errorParams)
-  }
-}
+const telemetryReport = async function ({ deployId, buildId, status, stepsCount, pluginsOptions, durationNs, siteInfo, telemetry, userNodeVersion, framework, testOpts, errorParams, }) {
+    try {
+        await trackBuildComplete({
+            deployId,
+            buildId,
+            status,
+            stepsCount,
+            pluginsOptions,
+            durationNs,
+            siteInfo,
+            telemetry,
+            userNodeVersion,
+            framework,
+            testOpts,
+        });
+    }
+    catch (error) {
+        await handleBuildError(error, errorParams);
+    }
+};

package/lib/core/missing_side_file.js

@@ -1,29 +1,17 @@
-import { relative } from 'path'
-
-import { pathExists } from 'path-exists'
-
-import { logMissingSideFile } from '../log/messages/core.js'
-
+import { relative } from 'path';
+import { pathExists } from 'path-exists';
+import { logMissingSideFile } from '../log/messages/core.js';
 // Some files like `_headers` and `_redirects` must be copied to the publish
 // directory to be used in production. When those are present in the repository
 // but not in the publish directory, this most likely indicates that the build
 // command accidentally forgot to copy those. We then print a warning message.
-export const warnOnMissingSideFiles = async function ({
-  buildDir,
-  netlifyConfig: {
-    build: { publish },
-  },
-  logs,
-}) {
-  await Promise.all(SIDE_FILES.map((sideFile) => warnOnMissingSideFile({ logs, sideFile, buildDir, publish })))
-}
-
-const SIDE_FILES = ['_headers', '_redirects']
-
+export const warnOnMissingSideFiles = async function ({ buildDir, netlifyConfig: { build: { publish }, }, logs, }) {
+    await Promise.all(SIDE_FILES.map((sideFile) => warnOnMissingSideFile({ logs, sideFile, buildDir, publish })));
+};
+const SIDE_FILES = ['_headers', '_redirects'];
 const warnOnMissingSideFile = async function ({ logs, sideFile, buildDir, publish }) {
-  if (!(await pathExists(`${buildDir}/${sideFile}`)) || (await pathExists(`${publish}/${sideFile}`))) {
-    return
-  }
-
-  logMissingSideFile(logs, sideFile, relative(buildDir, publish))
-}
+    if (!(await pathExists(`${buildDir}/${sideFile}`)) || (await pathExists(`${publish}/${sideFile}`))) {
+        return;
+    }
+    logMissingSideFile(logs, sideFile, relative(buildDir, publish));
+};

package/lib/core/normalize_flags.js

@@ -1,70 +1,59 @@
-import { env, execPath } from 'process'
-
-import { logFlags } from '../log/messages/config.js'
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js'
-
+import { env, execPath } from 'process';
+import { logFlags } from '../log/messages/config.js';
+import { removeFalsy } from '../utils/remove_falsy.js';
+import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js';
 // Normalize CLI flags
 export const normalizeFlags = function (flags, logs) {
-  const rawFlags = removeFalsy(flags)
-
-  // Combine the flags object env with the process.env
-  const combinedEnv = { ...env, ...rawFlags.env }
-  const defaultFlags = getDefaultFlags(rawFlags, combinedEnv)
-
-  // The telemetry flag requires specific logic to compute
-  const telemetryFlag = computeTelemetry(rawFlags, combinedEnv)
-
-  const mergedFlags = {
-    ...defaultFlags,
-    ...rawFlags,
-    ...telemetryFlag,
-    statsdOpts: { ...defaultFlags.statsd, ...rawFlags.statsd },
-    featureFlags: { ...defaultFlags.featureFlags, ...rawFlags.featureFlags },
-  }
-  const normalizedFlags = removeFalsy(mergedFlags)
-
-  logFlags(logs, rawFlags, normalizedFlags)
-
-  return normalizedFlags
-}
-
+    const rawFlags = removeFalsy(flags);
+    // Combine the flags object env with the process.env
+    const combinedEnv = { ...env, ...rawFlags.env };
+    const defaultFlags = getDefaultFlags(rawFlags, combinedEnv);
+    // The telemetry flag requires specific logic to compute
+    const telemetryFlag = computeTelemetry(rawFlags, combinedEnv);
+    const mergedFlags = {
+        ...defaultFlags,
+        ...rawFlags,
+        ...telemetryFlag,
+        statsdOpts: { ...defaultFlags.statsd, ...rawFlags.statsd },
+        featureFlags: { ...defaultFlags.featureFlags, ...rawFlags.featureFlags },
+    };
+    const normalizedFlags = removeFalsy(mergedFlags);
+    logFlags(logs, rawFlags, normalizedFlags);
+    return normalizedFlags;
+};
 // Default values of CLI flags
 const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
-  return {
-    env: envOpt,
-    nodePath: execPath,
-    token: combinedEnv.NETLIFY_AUTH_TOKEN,
-    mode: REQUIRE_MODE,
-    offline: false,
-    telemetry: false,
-    verbose: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
-    functionsDistDir: DEFAULT_FUNCTIONS_DIST,
-    edgeFunctionsDistDir: DEFAULT_EDGE_FUNCTIONS_DIST,
-    cacheDir: DEFAULT_CACHE_DIR,
-    deployId: combinedEnv.DEPLOY_ID,
-    buildId: combinedEnv.BUILD_ID,
-    debug: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
-    bugsnagKey: combinedEnv.BUGSNAG_KEY,
-    sendStatus: false,
-    saveConfig: false,
-    apiHost: 'api.netlify.com',
-    testOpts: {},
-    featureFlags: DEFAULT_FEATURE_FLAGS,
-    statsd: { port: DEFAULT_STATSD_PORT },
-    timeline: 'build',
-  }
-}
-
+    return {
+        env: envOpt,
+        nodePath: execPath,
+        token: combinedEnv.NETLIFY_AUTH_TOKEN,
+        mode: REQUIRE_MODE,
+        offline: false,
+        telemetry: false,
+        verbose: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
+        functionsDistDir: DEFAULT_FUNCTIONS_DIST,
+        edgeFunctionsDistDir: DEFAULT_EDGE_FUNCTIONS_DIST,
+        cacheDir: DEFAULT_CACHE_DIR,
+        deployId: combinedEnv.DEPLOY_ID,
+        buildId: combinedEnv.BUILD_ID,
+        debug: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
+        bugsnagKey: combinedEnv.BUGSNAG_KEY,
+        sendStatus: false,
+        saveConfig: false,
+        apiHost: 'api.netlify.com',
+        testOpts: {},
+        featureFlags: DEFAULT_FEATURE_FLAGS,
+        statsd: { port: DEFAULT_STATSD_PORT },
+        timeline: 'build',
+    };
+};
 // Compute the telemetry flag, it's disabled by default and we want to always disable it
 // if BUILD_TELEMETRY_DISABLED is passed.
 const computeTelemetry = function (flags, envOpts) {
-  return envOpts.BUILD_TELEMETRY_DISABLED ? { telemetry: false } : { telemetry: flags.telemetry }
-}
-
-const REQUIRE_MODE = 'require'
-const DEFAULT_EDGE_FUNCTIONS_DIST = '.netlify/edge-functions-dist/'
-const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/'
-const DEFAULT_CACHE_DIR = '.netlify/cache/'
-const DEFAULT_STATSD_PORT = 8125
+    return envOpts.BUILD_TELEMETRY_DISABLED ? { telemetry: false } : { telemetry: flags.telemetry };
+};
+const REQUIRE_MODE = 'require';
+const DEFAULT_EDGE_FUNCTIONS_DIST = '.netlify/edge-functions-dist/';
+const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/';
+const DEFAULT_CACHE_DIR = '.netlify/cache/';
+const DEFAULT_STATSD_PORT = 8125;

package/lib/core/severity.js

@@ -1,22 +1,20 @@
 // Used to extract exit codes and respective status strings
 // 1|2|3 indicate whether this was a user|plugin|system error.
 export const getSeverity = function (severity = FALLBACK_SEVERITY) {
-  const severityEntry = severity in SEVERITY_MAP ? SEVERITY_MAP[severity] : FALLBACK_SEVERITY_ENTRY
-  const success = severity === SUCCESS_SEVERITY
-  return { success, ...severityEntry }
-}
-
+    const severityEntry = severity in SEVERITY_MAP ? SEVERITY_MAP[severity] : FALLBACK_SEVERITY_ENTRY;
+    const success = severity === SUCCESS_SEVERITY;
+    return { success, ...severityEntry };
+};
 // Map error severities to exit codes and status (used for telemetry purposes)
-
 const SEVERITY_MAP = {
-  success: { severityCode: 0, status: 'success' },
-  none: { severityCode: 1, status: 'cancelled' },
-  info: { severityCode: 2, status: 'user-error' },
-  warning: { severityCode: 3, status: 'plugin-error' },
-  error: { severityCode: 4, status: 'system-error' },
-}
+    success: { severityCode: 0, status: 'success' },
+    none: { severityCode: 1, status: 'cancelled' },
+    info: { severityCode: 2, status: 'user-error' },
+    warning: { severityCode: 3, status: 'plugin-error' },
+    error: { severityCode: 4, status: 'system-error' },
+};
 /* eslint-enable no-magic-numbers */
-const SUCCESS_SEVERITY = 'success'
+const SUCCESS_SEVERITY = 'success';
 // Indicates a bug in our codebase
-const FALLBACK_SEVERITY = 'error'
-export const FALLBACK_SEVERITY_ENTRY = SEVERITY_MAP[FALLBACK_SEVERITY]
+const FALLBACK_SEVERITY = 'error';
+export const FALLBACK_SEVERITY_ENTRY = SEVERITY_MAP[FALLBACK_SEVERITY];

package/lib/core/user_node_version.js

@@ -1,41 +1,32 @@
-import { version as currentVersion, execPath } from 'process'
-
-import { execa } from 'execa'
-import semver from 'semver'
-
-import { addErrorInfo } from '../error/info.js'
-
+import { version as currentVersion, execPath } from 'process';
+import { execa } from 'execa';
+import semver from 'semver';
+import { addErrorInfo } from '../error/info.js';
 // Retrieve Node.js version if the Node.js path is using nvm.
 // `node.exe` on Windows, `bin/node` on Unix.
-const NVM_NODE_VERSION_REGEXP = /[/\\]v(\d+\.\d+\.\d+)[/\\](bin[/\\]node|node.exe)$/
-
+const NVM_NODE_VERSION_REGEXP = /[/\\]v(\d+\.\d+\.\d+)[/\\](bin[/\\]node|node.exe)$/;
 // Retrieve Node.js version from current process
 const getCurrentNodeVersion = function () {
-  return semver.clean(currentVersion)
-}
-
+    return semver.clean(currentVersion);
+};
 // Retrieve Node.js version from `--node-path` or fallback to extracting the current Node.js process version
 export const getUserNodeVersion = async function (nodePath) {
-  // No `--node-path` CLI flag, use the current node process version
-  if (nodePath === execPath) {
-    return getCurrentNodeVersion()
-  }
-
-  // Extract version from path
-  const result = NVM_NODE_VERSION_REGEXP.exec(nodePath)
-  if (result !== null) {
-    return result[1]
-  }
-
-  // Fallback to actually running `node --version` with the given nodePath
-  const { stdout } = await execa(nodePath, ['--version'], { reject: false })
-  const version = semver.clean(stdout)
-
-  if (version === null) {
-    const error = new Error(`Invalid --node-path CLI flag: ${nodePath}`)
-    addErrorInfo(error, { type: 'resolveConfig' })
-    throw error
-  }
-
-  return version
-}
+    // No `--node-path` CLI flag, use the current node process version
+    if (nodePath === execPath) {
+        return getCurrentNodeVersion();
+    }
+    // Extract version from path
+    const result = NVM_NODE_VERSION_REGEXP.exec(nodePath);
+    if (result !== null) {
+        return result[1];
+    }
+    // Fallback to actually running `node --version` with the given nodePath
+    const { stdout } = await execa(nodePath, ['--version'], { reject: false });
+    const version = semver.clean(stdout);
+    if (version === null) {
+        const error = new Error(`Invalid --node-path CLI flag: ${nodePath}`);
+        addErrorInfo(error, { type: 'resolveConfig' });
+        throw error;
+    }
+    return version;
+};

package/lib/env/changes.js

@@ -1,51 +1,43 @@
-import { env } from 'process'
-
-import filterObj from 'filter-obj'
-import mapObj from 'map-obj'
-
+import { env } from 'process';
+import filterObj from 'filter-obj';
+import mapObj from 'map-obj';
 // If plugins modify `process.env`, this is propagated in other plugins and in
 // `build.command`. Since those are different processes, we figure out when they
 // do this and communicate the new `process.env` to other processes.
 export const getNewEnvChanges = function (envBefore, netlifyConfig, netlifyConfigCopy) {
-  const processEnvChanges = diffEnv(envBefore, env)
-  const netlifyConfigEnvChanges = diffEnv(netlifyConfig.build.environment, netlifyConfigCopy.build.environment)
-  return { ...processEnvChanges, ...netlifyConfigEnvChanges }
-}
-
+    const processEnvChanges = diffEnv(envBefore, env);
+    const netlifyConfigEnvChanges = diffEnv(netlifyConfig.build.environment, netlifyConfigCopy.build.environment);
+    return { ...processEnvChanges, ...netlifyConfigEnvChanges };
+};
 const diffEnv = function (envBefore, envAfter) {
-  const envChanges = filterObj(envAfter, (name, value) => value !== envBefore[name])
-  const deletedEnv = filterObj(envBefore, (name) => envAfter[name] === undefined)
-  const deletedEnvA = mapObj(deletedEnv, setToNull)
-  return { ...envChanges, ...deletedEnvA }
-}
-
+    const envChanges = filterObj(envAfter, (name, value) => value !== envBefore[name]);
+    const deletedEnv = filterObj(envBefore, (name) => envAfter[name] === undefined);
+    const deletedEnvA = mapObj(deletedEnv, setToNull);
+    return { ...envChanges, ...deletedEnvA };
+};
 // `undefined` is not JSON-serializable (which is used in process IPC), so we
 // convert it to `null`
 // Note: `process.env[name] = undefined` actually does
 // `process.env[name] = 'undefined'` in Node.js.
 const setToNull = function (name) {
-  return [name, null]
-}
-
+    return [name, null];
+};
 // Set `process.env` changes from a previous different plugin.
 // Can also merge with a `currentEnv` plain object instead of `process.env`.
 export const setEnvChanges = function (envChanges, currentEnv = env) {
-  Object.entries(envChanges).forEach(([name, value]) => {
-    setEnvChange(name, value, currentEnv)
-  })
-  return { ...currentEnv }
-}
-
+    Object.entries(envChanges).forEach(([name, value]) => {
+        setEnvChange(name, value, currentEnv);
+    });
+    return { ...currentEnv };
+};
 const setEnvChange = function (name, value, currentEnv) {
-  if (currentEnv[name] === value) {
-    return
-  }
-
-  if (value === null) {
-    // `currentEnv` is a mutable variable
-    delete currentEnv[name]
-    return
-  }
-
-  currentEnv[name] = value
-}
+    if (currentEnv[name] === value) {
+        return;
+    }
+    if (value === null) {
+        // `currentEnv` is a mutable variable
+        delete currentEnv[name];
+        return;
+    }
+    currentEnv[name] = value;
+};

package/lib/env/main.js

@@ -1,19 +1,14 @@
-import { env } from 'process'
-
-import filterObj from 'filter-obj'
-
-import { getParentColorEnv } from '../log/colors.js'
-
+import { env } from 'process';
+import filterObj from 'filter-obj';
+import { getParentColorEnv } from '../log/colors.js';
 // Retrieve the environment variables passed to plugins and `build.command`
 // When run locally, this tries to emulate the production environment.
 export const getChildEnv = function ({ envOpt, env: allConfigEnv }) {
-  const parentColorEnv = getParentColorEnv()
-  const parentEnv = { ...env, ...allConfigEnv, ...envOpt, ...parentColorEnv }
-  return filterObj(parentEnv, shouldKeepEnv)
-}
-
+    const parentColorEnv = getParentColorEnv();
+    const parentEnv = { ...env, ...allConfigEnv, ...envOpt, ...parentColorEnv };
+    return filterObj(parentEnv, shouldKeepEnv);
+};
 const shouldKeepEnv = function (key) {
-  return !REMOVED_PARENT_ENV.has(key.toLowerCase())
-}
-
-const REMOVED_PARENT_ENV = new Set(['bugsnag_key'])
+    return !REMOVED_PARENT_ENV.has(key.toLowerCase());
+};
+const REMOVED_PARENT_ENV = new Set(['bugsnag_key']);