@netlify/build 28.0.1-beta → 28.1.0-framework-version-detection

package/src/steps/run_step.js

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

package/src/steps/run_steps.js

@@ -1,179 +0,0 @@
-/* eslint-disable max-lines */
-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,
-  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,
-        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,
-  }
-}
-/* eslint-enable max-lines */

package/src/steps/update_config.js

@@ -1,93 +0,0 @@
-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 })
-  // eslint-disable-next-line fp/no-mutation,no-param-reassign
-  errorParams.netlifyConfig = netlifyConfigA
-  return {
-    netlifyConfig: netlifyConfigA,
-    configMutations: configMutationsA,
-    headersPath: headersPathA,
-    redirectsPath: redirectsPathA,
-  }
-}
-
-const shouldUpdateConfig = async function ({ newConfigMutations, configSideFiles, headersPath, redirectsPath }) {
-  return (
-    newConfigMutations.length !== 0 || (await haveConfigSideFilesChanged(configSideFiles, headersPath, redirectsPath))
-  )
-}
-
-// The configuration mostly depends on `netlify.toml` and UI build settings.
-// However, it also uses some additional optional side files like `_redirects`.
-// Those are often created by the build command. When those are created, we need
-// to update the configuration. We detect this by checking for file existence
-// before and after running plugins and the build command.
-const haveConfigSideFilesChanged = async function (configSideFiles, headersPath, redirectsPath) {
-  const newSideFiles = await listConfigSideFiles([headersPath, redirectsPath])
-  return !isDeepStrictEqual(newSideFiles, configSideFiles)
-}
-
-// List all the files used for configuration besides `netlify.toml`.
-// This is useful when applying configuration mutations since those files
-// sometimes have higher priority and should therefore be deleted in order to
-// apply any configuration update on `netlify.toml`.
-export const listConfigSideFiles = async function (sideFiles) {
-  const configSideFiles = await pFilter(sideFiles, pathExists)
-  // eslint-disable-next-line fp/no-mutating-methods
-  return configSideFiles.sort()
-}
-
-// Validate each new configuration change
-const validateConfigMutations = function (newConfigMutations) {
-  try {
-    newConfigMutations.forEach(validateConfigMutation)
-  } catch (error) {
-    addErrorInfo(error, { type: 'pluginValidation' })
-    throw error
-  }
-}
-
-// Triggered when calling `netlifyConfig.{key} = undefined | null`
-// We do not allow this because the back-end only receives mutations as a
-// `netlify.toml`, i.e. cannot apply property deletions since `undefined` is
-// not serializable in TOML.
-const validateConfigMutation = function ({ value, keysString }) {
-  if (value === undefined || value === null) {
-    throw new Error(`Setting "netlifyConfig.${keysString}" to ${value} is not allowed.
-Please set this property to a specific value instead.`)
-  }
-}

package/src/telemetry/main.js

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