@netlify/build 27.20.4 → 27.20.5

package/lib/steps/run_steps.js

@@ -1,179 +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'
-
+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,
-  }
-}
+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

@@ -1,93 +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'
-
+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,
-  }
-}
-
+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))
-  )
-}
-
+    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)
-}
-
+    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()
-}
-
+    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
-  }
-}
-
+    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.`)
-  }
-}
+    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

@@ -1,136 +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
+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,
-}
-
+    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
-  }
-}
-
+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}` },
-  })
-}
-
+    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 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 }
-}
-
+    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
-}
+    if (loadedFrom === 'auto_install') {
+        return origin === 'ui' ? 'ui' : 'netlify_toml';
+    }
+    return loadedFrom;
+};