@netlify/build 0.4.48 → 1.0.0-dl-test

package/src/core/main.js

@@ -1,196 +0,0 @@
-require('../utils/polyfills')
-
-// This needs to be done before `chalk` is loaded.
-// Note: `chalk` is also required by some of our dependencies.
-// eslint-disable-next-line import/order
-const { setColorLevel } = require('../log/colors')
-setColorLevel()
-
-require('../error/process')
-
-const { getChildEnv } = require('../env/main')
-const { maybeCancelBuild } = require('../error/cancel')
-const { removeErrorColors } = require('../error/colors')
-const { reportBuildError } = require('../error/monitor/report')
-const { startErrorMonitor } = require('../error/monitor/start')
-const { logBuildStart, logBuildError, logBuildSuccess } = require('../log/main')
-const { logOldCliVersionError } = require('../log/old_version')
-const { startTimer, endTimer } = require('../log/timer')
-const { startUtils } = require('../plugins/child/utils')
-const { loadPlugins } = require('../plugins/load')
-const { getPluginsOptions } = require('../plugins/options')
-const { startPlugins, stopPlugins } = require('../plugins/spawn')
-const { reportStatuses } = require('../status/report')
-const { trackBuildComplete } = require('../telemetry/complete')
-
-const { getCommands, runCommands } = require('./commands')
-const { normalizeFlags, loadConfig } = require('./config')
-const { doDryRun } = require('./dry')
-
-/**
- * Netlify Build
- * @param  {object} flags - build configuration CLI flags
- * @param  {string} [flags.config] - Netlify config file path
- * @param  {string} [flags.cwd] - Current directory
- * @param  {string} [flags.token] - Netlify API token for authentication
- * @param  {string} [flags.siteId] - Netlify Site ID
- * @param  {string} [flags.context] - Build context
- * @param  {boolean} [flags.dry] - printing commands without executing them
- */
-const build = async function(flags) {
-  const buildTimer = startTimer()
-
-  logBuildStart()
-
-  const flagsA = normalizeFlags(flags)
-  const errorMonitor = startErrorMonitor(flagsA)
-
-  try {
-    const {
-      netlifyConfig,
-      configPath,
-      buildDir,
-      nodePath,
-      token,
-      api,
-      dry,
-      siteInfo,
-      constants,
-      context,
-      branch,
-      mode,
-    } = await loadConfig(flagsA)
-    const childEnv = await getChildEnv({ netlifyConfig, buildDir, context, branch, siteInfo, mode })
-
-    try {
-      const pluginsOptions = await getPluginsOptions({ netlifyConfig, buildDir, constants, mode, api })
-
-      const { commandsCount, error, statuses } = await buildRun({
-        pluginsOptions,
-        netlifyConfig,
-        configPath,
-        buildDir,
-        nodePath,
-        childEnv,
-        token,
-        dry,
-        constants,
-        mode,
-        api,
-        errorMonitor,
-      })
-
-      if (dry) {
-        return true
-      }
-
-      await reportStatuses(statuses, api, mode)
-
-      if (error !== undefined) {
-        throw error
-      }
-
-      logBuildSuccess()
-      const duration = endTimer(buildTimer, 'Netlify Build')
-      await trackBuildComplete({ commandsCount, netlifyConfig, duration, siteInfo, mode })
-      return true
-    } catch (error) {
-      await maybeCancelBuild(error, api)
-      await logOldCliVersionError(mode)
-      error.netlifyConfig = netlifyConfig
-      error.childEnv = childEnv
-      throw error
-    }
-  } catch (error) {
-    removeErrorColors(error)
-    await reportBuildError(error, errorMonitor)
-    logBuildError(error)
-    return false
-  }
-}
-
-const buildRun = async function({
-  pluginsOptions,
-  netlifyConfig,
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  token,
-  dry,
-  constants,
-  mode,
-  api,
-  errorMonitor,
-}) {
-  const utilsData = await startUtils(buildDir)
-  const childProcesses = await startPlugins({ pluginsOptions, buildDir, nodePath, childEnv, mode })
-
-  try {
-    return await executeCommands({
-      pluginsOptions,
-      childProcesses,
-      netlifyConfig,
-      utilsData,
-      configPath,
-      buildDir,
-      nodePath,
-      childEnv,
-      token,
-      dry,
-      constants,
-      mode,
-      api,
-      errorMonitor,
-    })
-  } finally {
-    await stopPlugins(childProcesses)
-  }
-}
-
-const executeCommands = async function({
-  pluginsOptions,
-  childProcesses,
-  netlifyConfig,
-  utilsData,
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  token,
-  dry,
-  constants,
-  mode,
-  api,
-  errorMonitor,
-}) {
-  const pluginsCommands = await loadPlugins({
-    pluginsOptions,
-    childProcesses,
-    netlifyConfig,
-    utilsData,
-    token,
-    constants,
-    mode,
-    api,
-  })
-
-  const { commands, commandsCount } = getCommands(pluginsCommands, netlifyConfig)
-
-  if (dry) {
-    doDryRun({ commands, commandsCount, configPath })
-    return {}
-  }
-
-  return runCommands({
-    commands,
-    configPath,
-    buildDir,
-    nodePath,
-    childEnv,
-    errorMonitor,
-    netlifyConfig,
-  })
-}
-
-module.exports = build

package/src/env/changes.js

@@ -1,49 +0,0 @@
-const process = require('process')
-
-const filterObj = require('filter-obj')
-const mapObj = require('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.
-const getNewEnvChanges = function(envBefore) {
-  const currentEnv = getCurrentEnv()
-  const envChanges = filterObj(currentEnv, (name, value) => value !== envBefore[name])
-  const deletedEnv = filterObj(envBefore, name => currentEnv[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]
-}
-
-// Set `process.env` changes from a previous different plugin.
-// Can also merge with a `currentEnv` plain object instead of `process.env`.
-const setEnvChanges = function(envChanges, currentEnv = getCurrentEnv()) {
-  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) {
-    delete currentEnv[name]
-    return
-  }
-
-  currentEnv[name] = value
-}
-
-const getCurrentEnv = function() {
-  return process.env
-}
-
-module.exports = { getNewEnvChanges, setEnvChanges }

package/src/env/git.js

@@ -1,27 +0,0 @@
-const execa = require('execa')
-
-const { removeFalsy } = require('../utils/remove_falsy')
-
-// Retrieve git-related information for use in environment variables.
-// git is optional and there might be not git repository.
-// We purposely keep this decoupled from the git utility.
-const getGitEnv = async function(buildDir, branch) {
-  const [COMMIT_REF, CACHED_COMMIT_REF] = await Promise.all([
-    git(['rev-parse', 'HEAD'], buildDir),
-    git(['rev-parse', 'HEAD^'], buildDir),
-  ])
-  const gitEnv = { BRANCH: branch, HEAD: branch, COMMIT_REF, CACHED_COMMIT_REF, PULL_REQUEST: 'false' }
-  const gitEnvA = removeFalsy(gitEnv)
-  return gitEnvA
-}
-
-const git = async function(args, cwd) {
-  try {
-    const { stdout } = await execa('git', args, { cwd })
-    return stdout
-  } catch (error) {
-    return
-  }
-}
-
-module.exports = { getGitEnv }

package/src/env/main.js

@@ -1,97 +0,0 @@
-const { omit } = require('../utils/omit')
-const { removeFalsy } = require('../utils/remove_falsy')
-
-const { getGitEnv } = require('./git')
-
-// Retrieve the environment variables passed to plugins and `build.command`
-// When run locally, this tries to emulate the production environment.
-const getChildEnv = async function({ netlifyConfig, buildDir, branch, context, siteInfo, mode }) {
-  if (mode === 'buildbot') {
-    return process.env
-  }
-
-  const defaultEnv = getDefaultEnv()
-  const configurableEnv = getConfigurableEnv()
-  const configEnv = getConfigEnv(netlifyConfig)
-  const forcedEnv = await getForcedEnv({ buildDir, branch, context, siteInfo })
-  return {
-    ...removeFalsy(defaultEnv),
-    ...process.env,
-    ...removeFalsy(configurableEnv),
-    ...removeFalsy(configEnv),
-    ...removeFalsy(forcedEnv),
-  }
-}
-
-// Environment variables that can be unset by local ones or configuration ones
-const getDefaultEnv = function() {
-  return {}
-}
-
-// Environment variables that can be unset by configuration ones but not local
-const getConfigurableEnv = function() {
-  return {
-    // Localization
-    LANG: 'en_US.UTF-8',
-    LANGUAGE: 'en_US:en',
-    LC_ALL: 'en_US.UTF-8',
-    // Disable telemetry of some tools
-    GATSBY_TELEMETRY_DISABLED: '1',
-    NEXT_TELEMETRY_DISABLED: '1',
-  }
-}
-
-// Environment variables specified in UI settings or in `build.environment`
-const getConfigEnv = function({ build: { environment } }) {
-  return omit(environment, READONLY_ENV)
-}
-
-// Those environment variables cannot be overriden by configuration
-const READONLY_ENV = [
-  // Set in local builds
-  'BRANCH',
-  'CACHED_COMMIT_REF',
-  'COMMIT_REF',
-  'CONTEXT',
-  'HEAD',
-  'REPOSITORY_URL',
-  'URL',
-
-  // Purposely left unset in local builds
-  'NETLIFY',
-
-  // Not set in local builds because there is CI build/deploy, incoming hooks nor PR
-  'BUILD_ID',
-  'DEPLOY_ID',
-  'DEPLOY_PRIME_URL',
-  'DEPLOY_URL',
-  'INCOMING_HOOK_BODY',
-  'INCOMING_HOOK_TITLE',
-  'INCOMING_HOOK_URL',
-  'NETLIFY_BUILD_BASE',
-  'NETLIFY_BUILD_LIFECYCLE_TRIAL',
-  'NETLIFY_IMAGES_CDN_DOMAIN',
-  'PULL_REQUEST',
-  'REVIEW_ID',
-]
-
-// Environment variables that can be unset by neither local nor configuration
-const getForcedEnv = async function({
-  buildDir,
-  branch,
-  context,
-  siteInfo: { url, build_settings: { repo_url } = {} },
-}) {
-  const gitEnv = await getGitEnv(buildDir, branch)
-  return {
-    // Netlify Site information
-    URL: url,
-    REPOSITORY_URL: repo_url,
-    // Configuration file context
-    CONTEXT: context,
-    // Git-related environment variables
-    ...gitEnv,
-  }
-}
-
-module.exports = { getChildEnv }

package/src/env/metadata.js

@@ -1,81 +0,0 @@
-const { env } = require('process')
-
-const filterObj = require('filter-obj')
-
-// Retrieve enviroment variables used in error monitoring
-const getEnvMetadata = function(childEnv = env) {
-  return filterObj(childEnv, isEnvMetadata)
-}
-
-const isEnvMetadata = function(name) {
-  return ENVIRONMENT_VARIABLES.includes(name)
-}
-
-// This is sorted by most useful in debugging to least
-const ENVIRONMENT_VARIABLES = [
-  // URL and IDs
-  'BUILD_ID',
-  'DEPLOY_ID',
-  'REPOSITORY_URL',
-  'URL',
-  'DEPLOY_URL',
-  'DEPLOY_PRIME_URL',
-
-  // Git
-  'HEAD',
-  'COMMIT_REF',
-  'CACHED_COMMIT_REF',
-  'BRANCH',
-  'CONTEXT',
-  'PULL_REQUEST',
-  'REVIEW_ID',
-
-  // Node
-  'NODE_VERSION',
-  'AWS_LAMBDA_JS_RUNTIME',
-  'NPM_VERSION',
-  'YARN_VERSION',
-  'NPM_FLAGS',
-  'YARN_FLAGS',
-  'NVM_FLAGS',
-  'NODE_ENV',
-
-  // Go
-  'GO_VERSION',
-  'GO_IMPORT_PATH',
-  'GOCACHE',
-  'GOPATH',
-  'GOROOT',
-
-  // Ruby
-  'RUBY_VERSION',
-  'GEM_HOME',
-  'GEM_PATH',
-  'GIMME_GCO_ENABLED',
-  'GIMME_ENV_PREFIX',
-  'GIMME_GO_PREFIX',
-  'GIMME_NO_ENV_ALIAS',
-  'GIMME_TYPE',
-  'IRBRC',
-  'MY_RUBY_HOME',
-
-  // Hugo
-  'HUGO_VERSION',
-
-  // Java
-  'JAVA_VERSION',
-
-  // PHP
-  'PHP_VERSION',
-
-  // Python
-  'PIPENV_DEFAULT_PYTHON_VERSION',
-  'PIPENV_RUNTIME',
-  'PIPENV_VENV_IN_PROJECT',
-
-  // Git LFS
-  'GIT_LFS_ENABLED',
-  'GIT_LFS_FETCH_INCLUDE',
-]
-
-module.exports = { getEnvMetadata }

package/src/error/api.js

@@ -1,32 +0,0 @@
-const mapObj = require('map-obj')
-
-const { addErrorInfo } = require('./info')
-
-// Wrap `api.*` methods so that they add more error information
-const addApiErrorHandlers = function(api) {
-  if (api === undefined) {
-    return
-  }
-
-  return mapObj(api, addErrorHandler)
-}
-
-const addErrorHandler = function(key, value) {
-  if (typeof value !== 'function') {
-    return [key, value]
-  }
-
-  const valueA = apiMethodHandler.bind(null, key, value)
-  return [key, valueA]
-}
-
-const apiMethodHandler = async function(endpoint, method, parameters, ...args) {
-  try {
-    return await method(parameters, ...args)
-  } catch (error) {
-    addErrorInfo(error, { type: 'api', location: { endpoint, parameters } })
-    throw error
-  }
-}
-
-module.exports = { addApiErrorHandlers }

package/src/error/build.js

@@ -1,32 +0,0 @@
-const { addErrorInfo } = require('./info')
-
-// Retrieve error information from child process and re-build it in current
-// process. We need this since errors are not JSON-serializable.
-const buildError = function({ type, plugin, location, name, message, stack, ...errorProps }) {
-  const error = new Error('')
-
-  assignErrorProps(error, { name, message, stack })
-  // Assign static error properties (if any)
-  Object.assign(error, errorProps)
-
-  // Distinguish between utils.build.*() errors and uncaught exceptions / bugs
-  if (type !== undefined) {
-    addErrorInfo(error, { type, plugin, location })
-  }
-  return error
-}
-
-// Make sure `name`, `message` and `stack` are not enumerable
-const assignErrorProps = function(error, values) {
-  ERROR_PROPS.forEach(name => {
-    assignErrorProp(error, name, values[name])
-  })
-}
-
-const ERROR_PROPS = ['name', 'message', 'stack']
-
-const assignErrorProp = function(error, name, value) {
-  Object.defineProperty(error, name, { value, enumerable: false, writable: true, configurable: true })
-}
-
-module.exports = { buildError }

package/src/error/cancel.js

@@ -1,22 +0,0 @@
-const {
-  env: { DEPLOY_ID },
-} = require('process')
-
-const { getErrorInfo } = require('./info')
-
-// Cancel builds, for example when a plugin uses `utils.build.cancelBuild()`
-const maybeCancelBuild = async function(error, api) {
-  if (api === undefined || !DEPLOY_ID) {
-    return
-  }
-
-  const { type } = getErrorInfo(error)
-
-  if (type !== 'cancelBuild') {
-    return
-  }
-
-  await api.cancelSiteDeploy({ deploy_id: DEPLOY_ID })
-}
-
-module.exports = { maybeCancelBuild }

package/src/error/colors.js

@@ -1,13 +0,0 @@
-const stripAnsi = require('strip-ansi')
-
-// Remove ANSI sequences from `error.message`
-const removeErrorColors = function(error) {
-  if (!(error instanceof Error)) {
-    return
-  }
-
-  error.message = stripAnsi(error.message)
-  error.stack = stripAnsi(error.stack)
-}
-
-module.exports = { removeErrorColors }

package/src/error/info.js

@@ -1,12 +0,0 @@
-// Add information related to an error without colliding with existing properties
-const addErrorInfo = function(error, info) {
-  error[INFO_SYM] = { ...error[INFO_SYM], ...info }
-}
-
-const getErrorInfo = function(error) {
-  return error[INFO_SYM] || {}
-}
-
-const INFO_SYM = Symbol('info')
-
-module.exports = { addErrorInfo, getErrorInfo, INFO_SYM }

package/src/error/monitor/normalize.js

@@ -1,50 +0,0 @@
-// We group errors by `error.message`. However some `error.message` contain
-// unique IDs, etc. which defeats that grouping. So we normalize those to make
-// them consistent
-const normalizeGroupingMessage = function(message, type) {
-  const messageA = removeDependenciesLogs(message, type)
-  return NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA)
-}
-
-// Discard debug/info installation information
-const removeDependenciesLogs = function(message, type) {
-  if (type !== 'dependencies') {
-    return message
-  }
-
-  return message
-    .split('\n')
-    .filter(isErrorLine)
-    .join('\n')
-}
-
-const isErrorLine = function(line) {
-  return ERROR_LINES.some(errorLine => line.startsWith(errorLine))
-}
-
-const ERROR_LINES = [
-  // Prefix for npm
-  'npm ERR!',
-  // Prefix for Yarn
-  'error',
-]
-
-const normalizeMessage = function(message, [regExp, replacement]) {
-  return message.replace(regExp, replacement)
-}
-
-const NORMALIZE_REGEXPS = [
-  // File paths
-  [/(["'` ]|^)([^"'` ]*[/\\][^"'` ]*)(["'` ]|$)/gm, '$1/file/path$3'],
-  // Semantic versions
-  [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
-  [/version "[^"]+"/g, 'version "1.0.0"'],
-  // Cypress plugin prints the user's platform
-  [/^Platform: .*/gm, ''],
-  // URLs
-  [/https?:[\w.+_~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
-  // Numbers, e.g. number of issues/problems
-  [/\d+/g, '0'],
-]
-
-module.exports = { normalizeGroupingMessage }

package/src/error/monitor/print.js

@@ -1,43 +0,0 @@
-const { log } = require('../../log/logger.js')
-
-// Print event payload instead of sending actual request during tests
-const printEventForTest = function({
-  errors: [{ errorClass, errorMessage }],
-  context,
-  groupingHash,
-  severity,
-  unhandled,
-  app: { releaseStage, version, type },
-  device: {
-    runtimeVersions: { node },
-  },
-  _metadata: { location, plugin: { package, homepage } = {}, packageJson, env: { BUILD_ID } = {}, other },
-}) {
-  const eventString = JSON.stringify(
-    {
-      errorClass,
-      errorMessage,
-      context,
-      groupingHash,
-      severity,
-      unhandled,
-      releaseStage,
-      version,
-      type,
-      node,
-      location,
-      package,
-      packageJson: packageJson !== undefined,
-      homepage,
-      BUILD_ID,
-      other,
-    },
-    null,
-    2,
-  )
-  log(`\nError monitoring payload:\n${eventString}`)
-}
-
-module.exports = {
-  printEventForTest,
-}