@netlify/build 27.12.1-beta → 27.13.0

package/src/core/main.js

@@ -1,29 +1,12 @@
-/* eslint-disable max-lines, import/max-dependencies */
 import { handleBuildError } from '../error/handle.js'
-import { getErrorInfo } from '../error/info.js'
-import { startErrorMonitor } from '../error/monitor/start.js'
-import { getBufferLogs, getSystemLogger } from '../log/logger.js'
-import { logBuildStart, logTimer, logBuildSuccess } 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 { getSteps } from '../steps/get.js'
-import { runSteps } from '../steps/run_steps.js'
+import { logTimer, logBuildSuccess } from '../log/messages/core.js'
 import { trackBuildComplete } from '../telemetry/main.js'
-import { initTimers, measureDuration } from '../time/main.js'
 import { reportTimers } from '../time/report.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'
+import { execBuild, startBuild } from './build.js'
 import { getSeverity } from './severity.js'
 
+export { startDev } from './dev.js'
 export { runCoreSteps } from '../steps/run_core_steps.js'
 
 /**
@@ -135,526 +118,6 @@ export default async function buildSite(flags = {}) {
   }
 }
 
-// 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.
-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,
-}) {
-  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
-  // eslint-disable-next-line fp/no-mutating-assign
-  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,
-  })
-  return {
-    pluginsOptions: pluginsOptionsA,
-    netlifyConfig: netlifyConfigA,
-    siteInfo,
-    userNodeVersion,
-    stepsCount,
-    timers: timersB,
-    configMutations,
-  }
-}
-
-const execBuild = measureDuration(tExecBuild, 'total', { parentTag: 'build_site' })
-
-// Runs a build then report any plugin statuses
-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,
-}) {
-  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,
-    })
-    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,
-}) {
-  const { pluginsOptions: pluginsOptionsA, timers: timersA } = await getPluginsOptions({
-    pluginsOptions,
-    netlifyConfig,
-    siteInfo,
-    buildDir,
-    nodePath,
-    packageJson,
-    userNodeVersion,
-    mode,
-    api,
-    logs,
-    debug,
-    sendStatus,
-    timers,
-    testOpts,
-    featureFlags,
-  })
-  // eslint-disable-next-line fp/no-mutation, no-param-reassign
-  errorParams.pluginsOptions = pluginsOptionsA
-
-  const { childProcesses, timers: timersB } = await startPlugins({
-    pluginsOptions: pluginsOptionsA,
-    buildDir,
-    childEnv,
-    logs,
-    debug,
-    timers: timersA,
-  })
-
-  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,
-    })
-
-    await Promise.all([
-      warnOnMissingSideFiles({ buildDir, netlifyConfig: netlifyConfigA, logs }),
-      warnOnLingeringProcesses({ mode, logs, testOpts }),
-    ])
-
-    return {
-      stepsCount,
-      netlifyConfig: netlifyConfigA,
-      statuses,
-      pluginsOptions: pluginsOptionsA,
-      failedPlugins,
-      timers: timersC,
-      configMutations,
-    }
-  } finally {
-    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,
-}) {
-  const { pluginsSteps, timers: timersA } = await loadPlugins({
-    pluginsOptions,
-    childProcesses,
-    packageJson,
-    timers,
-    logs,
-    debug,
-    verbose,
-  })
-
-  const { steps, events } = 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 }
-}
-
 // Logs and reports that a build successfully ended
 const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts }) {
   if (dry) {
@@ -700,4 +163,3 @@ const telemetryReport = async function ({
     await handleBuildError(error, errorParams)
   }
 }
-/* eslint-enable max-lines, import/max-dependencies */

package/src/core/normalize_flags.js

@@ -53,6 +53,7 @@ const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
     testOpts: {},
     featureFlags: DEFAULT_FEATURE_FLAGS,
     statsd: { port: DEFAULT_STATSD_PORT },
+    timeline: 'build',
   }
 }
 

package/src/log/messages/compatibility.js

@@ -5,9 +5,20 @@ import { getPluginOrigin } from '../description.js'
 import { logArray, logSubHeader, logWarningArray, logWarningSubHeader } from '../logger.js'
 import { THEME } from '../theme.js'
 
+export const logRuntime = (logs, pluginOptions) => {
+  const runtimes = pluginOptions.filter(isRuntime)
+
+  // Once we have more runtimes, this hardcoded check should be removed
+  if (runtimes.length > 1) {
+    logSubHeader(logs, 'Using Next.js Runtime')
+  }
+}
+
 export const logLoadingPlugins = function (logs, pluginsOptions, debug) {
   const loadingPlugins = pluginsOptions
     .filter(isNotCorePlugin)
+    // We don't want to show runtimes as plugins
+    .filter((plugin) => !isRuntime(plugin))
     .map((pluginOptions) => getPluginDescription(pluginOptions, debug))
 
   if (loadingPlugins.length === 0) {
@@ -23,6 +34,11 @@ const isNotCorePlugin = function ({ origin }) {
   return origin !== 'core'
 }
 
+const isRuntime = function ({ packageName }) {
+  // Make this a bit more robust in the future
+  return ['@netlify/next-runtime'].includes(packageName)
+}
+
 const getPluginDescription = function (
   {
     packageName,

package/src/log/messages/config.js

@@ -52,6 +52,8 @@ const INTERNAL_FLAGS = [
   'mode',
   'apiHost',
   'cacheDir',
+  'systemLogFile',
+  'timeline',
 ]
 const HIDDEN_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS, ...INTERNAL_FLAGS]
 const HIDDEN_DEBUG_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS]

package/src/plugins/child/validate.js

@@ -1,6 +1,6 @@
 import { addErrorInfo } from '../../error/info.js'
 import { serializeArray } from '../../log/serialize.js'
-import { EVENTS } from '../events.js'
+import { DEV_EVENTS, EVENTS } from '../events.js'
 
 // Validate the shape of a plugin return value
 export const validatePlugin = function (logic) {
@@ -22,7 +22,7 @@ export const validatePlugin = function (logic) {
 
 // All other properties are event handlers
 const validateEventHandler = function (value, propName) {
-  if (!EVENTS.includes(propName)) {
+  if (!EVENTS.includes(propName) && !DEV_EVENTS.includes(propName)) {
     throw new Error(`Invalid event '${propName}'.
 Please use a valid event name. One of:
 ${serializeArray(EVENTS)}`)

package/src/plugins/events.js

@@ -1,4 +1,4 @@
-export { EVENTS } from '@netlify/config'
+export { DEV_EVENTS, EVENTS } from '@netlify/config'
 
 const isAmongEvents = function (events, event) {
   return events.includes(event)

package/src/plugins/spawn.js

@@ -3,7 +3,12 @@ import { fileURLToPath } from 'url'
 import { execaNode } from 'execa'
 
 import { addErrorInfo } from '../error/info.js'
-import { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } from '../log/messages/compatibility.js'
+import {
+  logRuntime,
+  logLoadingPlugins,
+  logOutdatedPlugins,
+  logIncompatiblePlugins,
+} from '../log/messages/compatibility.js'
 import { measureDuration } from '../time/main.js'
 
 import { getEventFromChild } from './ipc.js'
@@ -18,6 +23,7 @@ const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url))
 //  - logs can be buffered which allows manipulating them for log shipping,
 //    transforming and parallel plugins
 const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs, debug }) {
+  logRuntime(logs, pluginsOptions)
   logLoadingPlugins(logs, pluginsOptions, debug)
   logOutdatedPlugins(logs, pluginsOptions)
   logIncompatiblePlugins(logs, pluginsOptions)

package/src/plugins_core/deploy/buildbot_client.js

@@ -84,7 +84,18 @@ const getDeployDir = function ({ buildDir, repositoryRoot, constants: { PUBLISH_
 
 // We distinguish between user errors and system errors during deploys
 const handleDeployError = function (error, errorType) {
-  const errorA = new Error(`Deploy did not succeed: ${error}`)
+  const errorIs422 = error !== undefined && error.code === '422'
+
+  const errMsg = errorIs422
+    ? `
+    File upload failed because of mismatched SHAs.
+    This can happen when files are changed after the deployment process has started but before they are uploaded.
+
+    Error: ${error}
+    `
+    : `Deploy did not succeed: ${error}`
+
+  const errorA = new Error(errMsg)
   const errorInfo =
     errorType === 'user' ? { type: 'resolveConfig' } : { type: 'coreStep', location: { coreStepName: 'Deploy site' } }
   addErrorInfo(errorA, errorInfo)