@netlify/build 28.0.1-beta → 28.1.0

package/src/core/config.js

@@ -1,186 +0,0 @@
-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/src/core/constants.js

@@ -1,156 +0,0 @@
-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/src/core/dry.js

@@ -1,39 +0,0 @@
-import pFilter from 'p-filter'
-
-import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js'
-import { runsOnlyOnBuildFailure } from '../plugins/events.js'
-
-// If the `dry` flag is specified, do a dry run
-export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }) {
-  const successSteps = await pFilter(steps, ({ event, condition }) =>
-    shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }),
-  )
-  const eventWidth = Math.max(...successSteps.map(getEventLength))
-  const stepsCount = successSteps.length
-
-  logDryRunStart({ logs, eventWidth, stepsCount })
-
-  successSteps.forEach((step, index) => {
-    logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount })
-  })
-
-  logDryRunEnd(logs)
-}
-
-const shouldIncludeStep = async function ({
-  buildDir,
-  event,
-  condition,
-  netlifyConfig,
-  constants,
-  buildbotServerSocket,
-}) {
-  return (
-    !runsOnlyOnBuildFailure(event) &&
-    (condition === undefined || (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket })))
-  )
-}
-
-const getEventLength = function ({ event }) {
-  return event.length
-}

package/src/core/feature_flags.js

@@ -1,21 +0,0 @@
-// From CLI `--featureFlags=a,b,c` to programmatic `{ a: true, b: true, c: true }`
-export const normalizeCliFeatureFlags = function (cliFeatureFlags) {
-  return Object.assign({}, ...cliFeatureFlags.split(',').filter(isNotEmpty).map(getFeatureFlag))
-}
-
-const isNotEmpty = function (name) {
-  return name.trim() !== ''
-}
-
-const getFeatureFlag = function (name) {
-  return { [name]: true }
-}
-
-// Default values for feature flags
-export const DEFAULT_FEATURE_FLAGS = {
-  buildbot_es_modules_esbuild: false,
-  buildbot_zisi_trace_nft: false,
-  buildbot_zisi_esbuild_parser: false,
-  edge_functions_cache_cli: false,
-  edge_functions_produce_eszip: false,
-}

package/src/core/flags.js

@@ -1,194 +0,0 @@
-/* eslint eslint-comments/no-use: off, max-lines: off */
-
-const jsonParse = function (value) {
-  return value === undefined ? undefined : JSON.parse(value)
-}
-
-// All CLI flags
-export const FLAGS = {
-  config: {
-    string: true,
-    describe: `Path to the configuration file.
-Defaults to any netlify.toml in the git repository root directory or the base directory`,
-  },
-  defaultConfig: {
-    string: true,
-    describe: `JSON configuration object containing default values.
-Each configuration default value is used unless overriden through the main configuration file.
-Default: none.`,
-    coerce: jsonParse,
-    hidden: true,
-  },
-  cachedConfig: {
-    string: true,
-    describe: `JSON configuration object returned by @netlify/config when --output=/ is used
-or when using @netlify/config programmatically.
-This is done as a performance optimization to cache the configuration loading logic.
-Default: none.`,
-    coerce: jsonParse,
-    hidden: true,
-  },
-  cachedConfigPath: {
-    string: true,
-    describe: `File path to the JSON configuration object returned by @netlify/config
-when --output=/path is used.
-This is done as a performance optimization to cache the configuration loading logic.
-Default: none.`,
-    hidden: true,
-  },
-  cwd: {
-    string: true,
-    describe: `Current directory. Used to retrieve the configuration file.
-Default: current directory`,
-  },
-  repositoryRoot: {
-    string: true,
-    describe: `Git repository root directory. Used to retrieve the configuration file.
-Default: automatically guessed`,
-  },
-  apiHost: {
-    string: true,
-    describe: `Netlify API endpoint.
-Default: automatically guessed`,
-  },
-  token: {
-    string: true,
-    describe: `Netlify API token for authentication.
-The NETLIFY_AUTH_TOKEN environment variable can be used as well.`,
-  },
-  siteId: {
-    string: true,
-    describe: `Netlify Site ID.`,
-  },
-  deployId: {
-    string: true,
-    describe: `Netlify Deploy ID.
-Default: automatically guessed`,
-  },
-  buildId: {
-    string: true,
-    describe: `Netlify Build ID.
-Default: automatically guessed`,
-  },
-  context: {
-    string: true,
-    describe: `Build context.
-Default: 'production'`,
-  },
-  branch: {
-    string: true,
-    describe: `Repository branch.
-Default: automatically guessed`,
-  },
-  framework: {
-    string: true,
-    describe: 'Front-end framework.',
-    hidden: true,
-  },
-  baseRelDir: {
-    boolean: true,
-    describe: `Feature flag meant for backward compatibility.
-When enabled, if the 'build.base' configuration property is defined, it is used
-to try to retrieve a second configuration file and discard the first one.
-Default: true`,
-    hidden: true,
-  },
-  dry: {
-    alias: 'dry-run',
-    boolean: true,
-    describe: `Run in dry mode, i.e. printing steps without executing them.
-Default: false`,
-  },
-  nodePath: {
-    string: true,
-    describe: `Path to the Node.js binary to use in the build command and plugins.
-Default: Current Node.js binary`,
-  },
-  functionsDistDir: {
-    string: true,
-    describe: `Path to the directory where packaged functions are kept.
-Default: automatically guessed`,
-    hidden: true,
-  },
-  edgeFunctionsDistDir: {
-    string: true,
-    describe: `Path to the directory where packaged Edge Functions are kept.
-Default: automatically guessed`,
-    hidden: true,
-  },
-  cacheDir: {
-    string: true,
-    describe: `Path to the cache directory.
-Default: .netlify/cache/`,
-    hidden: true,
-  },
-  buildbotServerSocket: {
-    string: true,
-    describe: `Path to the buildbot server socket. This is used to connect to the buildbot to trigger deploys.`,
-    hidden: true,
-  },
-  telemetry: {
-    boolean: true,
-    describe: `Enable telemetry.
-Default: false`,
-  },
-  mode: {
-    string: true,
-    describe: `Environment in which this is loaded. Can be:
-  - 'buildbot': within Netlify Buildbot
-  - 'cli': within Netlify CLI
-  - 'require': through import('@netlify/build')`,
-    hidden: true,
-  },
-  debug: {
-    boolean: true,
-    describe: 'Print user-facing debugging information',
-    hidden: true,
-  },
-  verbose: {
-    boolean: true,
-    describe: 'Print internal debugging information',
-    hidden: true,
-  },
-  sendStatus: {
-    boolean: true,
-    describe: 'Whether plugin statuses should be sent to the Netlify API',
-    hidden: true,
-  },
-  saveConfig: {
-    boolean: true,
-    describe: 'Whether configuration changes should be saved to netlify.toml',
-    hidden: true,
-  },
-  testOpts: {
-    describe: 'Options for testing only',
-    hidden: true,
-  },
-  featureFlags: {
-    describe: 'Comma-separated list of feature flags to enable unreleased features',
-    hidden: true,
-  },
-  statsd: {
-    describe: 'Statsd-related options, for performance measuring',
-    hidden: true,
-  },
-  'statsd.host': {
-    type: 'string',
-    describe: 'Statsd host',
-    hidden: true,
-  },
-  'statsd.port': {
-    type: 'number',
-    describe: 'Statsd port',
-    hidden: true,
-  },
-  offline: {
-    boolean: true,
-    describe: `Do not send requests to the Netlify API to retrieve site settings.
-Default: false`,
-  },
-  buffer: {
-    boolean: true,
-    describe: 'Buffer output instead of printing it',
-  },
-}

package/src/core/lingering.js

@@ -1,85 +0,0 @@
-import psList from 'ps-list'
-
-import { logLingeringProcesses } from '../log/messages/core.js'
-
-// Print a warning when some build processes are still running.
-// We cannot rely on using the process tree:
-//  - This is because it is impossible to know whether a process was a child of
-//    of another once its parent process has exited. When that happens, the s
-//    child becomes inherited by `init`, changing its `ppid`. The information
-//    about the original parent is then lost.
-//  - The only way to implement this would be to repeatedly list processes as
-//    the build command is ongoing. However, this would fail to detect processes
-//    spawned just before the build commands ends.
-// We cannot list processes before and after the build command and use the
-// difference.
-//  - This is because other processes (unrelated to @netlify/build) might be
-//    running at the same time. This includes OS background processes.
-// Therefore, we run this in a controlled environment only (the buildbot) and
-// exclude specific processes manually. This is a lesser evil, although still
-// quite hacky.
-export const warnOnLingeringProcesses = async function ({
-  mode,
-  logs,
-  testOpts: { silentLingeringProcesses = false },
-}) {
-  if (mode !== 'buildbot' || silentLingeringProcesses) {
-    return
-  }
-
-  const processes = await psList()
-
-  const commands = processes.map(getCommand).filter(isNotIgnoredCommand)
-
-  if (commands.length === 0) {
-    return
-  }
-
-  logLingeringProcesses(logs, commands)
-}
-
-// `cmd` is only available on Unix. Unlike `name`, it includes the arguments.
-const getCommand = function ({ name, cmd = name }) {
-  return cmd
-}
-
-// We ignore any command known to be internal to the buildbot.
-// We also ignore commands known not to complete properly in builds if they are
-// widely used.
-const isNotIgnoredCommand = function (command) {
-  return !IGNORED_COMMANDS.some((ignoredCommand) => matchesIgnoredCommand(command, ignoredCommand))
-}
-
-const matchesIgnoredCommand = function (command, ignoredCommand) {
-  if (typeof ignoredCommand === 'string') {
-    return command.includes(ignoredCommand)
-  }
-
-  return ignoredCommand.test(command)
-}
-
-const IGNORED_COMMANDS = [
-  // TODO: Those can most likely be removed
-  'ps',
-  'grep',
-  'bash',
-
-  // Internal buildbot commands
-  '[build]',
-  /buildbot.*\[node]/,
-  // buildbot's main Bash script
-  '/opt/build-bin/build',
-  // `@netlify/build` binary itself
-  'netlify-build',
-  // Plugin child processes spawned by @netlify/build
-  '@netlify/build',
-  // Shown for parent processes with currently running child processes.
-  // Happens on `ps` itself.
-  'defunct',
-
-  // Processes often left running. We should report those but don't because of
-  // how common those are in production builds
-  'gatsby-telemetry',
-  'jest-worker',
-  'broccoli-babel-transpiler',
-]