@netlify/build 0.4.48 → 1.0.0-dl-test

package/src/log/main.js

@@ -1,348 +0,0 @@
-const {
-  env: { NETLIFY_BUILD_DEBUG },
-} = require('process')
-
-const { arrowDown } = require('figures')
-const filterObj = require('filter-obj')
-const prettyMs = require('pretty-ms')
-
-const { name, version } = require('../../package.json')
-const { serializeLogError } = require('../error/parse/serialize_log')
-const { omit } = require('../utils/omit')
-const { removeFalsy } = require('../utils/remove_falsy')
-
-const { getCommandDescription, getBuildCommandDescription, getPluginOrigin } = require('./description')
-const {
-  log,
-  logMessage,
-  logObject,
-  logArray,
-  logHeader,
-  logErrorHeader,
-  logSubHeader,
-  logErrorSubHeader,
-} = require('./logger')
-const { THEME } = require('./theme')
-
-const logBuildStart = function() {
-  logHeader('Netlify Build')
-  logSubHeader('Version')
-  logMessage(`${name} ${version}`)
-}
-
-const logFlags = function(flags) {
-  const hiddenFlags = flags.mode === 'buildbot' ? [...HIDDEN_FLAGS, 'nodePath'] : HIDDEN_FLAGS
-  const flagsA = omit(flags, hiddenFlags)
-  logSubHeader('Flags')
-  logObject(flagsA)
-}
-
-const HIDDEN_FLAGS = ['token', 'cachedConfig', 'defaultConfig']
-
-const logBuildDir = function(buildDir) {
-  logSubHeader('Current directory')
-  logMessage(buildDir)
-}
-
-const logConfigPath = function(configPath = NO_CONFIG_MESSAGE) {
-  logSubHeader('Config file')
-  logMessage(configPath)
-}
-
-const NO_CONFIG_MESSAGE = 'No config file was defined: using default values.'
-
-const logConfig = function(netlifyConfig) {
-  if (!NETLIFY_BUILD_DEBUG) {
-    return
-  }
-
-  logSubHeader('Resolved config')
-  logObject(simplifyConfig(netlifyConfig))
-}
-
-const logConfigOnError = function(netlifyConfig) {
-  if (netlifyConfig === undefined) {
-    return
-  }
-
-  logMessage(THEME.errorSubHeader('Resolved config'))
-  logObject(simplifyConfig(keepPublicProperties(netlifyConfig)))
-}
-
-// Make sure we are not printing secret values. Use an allow list.
-const keepPublicProperties = function({
-  build: { base, command, functions, ignore, processing, publish },
-  headers,
-  plugins,
-  redirects,
-}) {
-  const pluginsA = plugins.map(keepPluginPublicProperties)
-  return {
-    build: { base, command, functions, ignore, processing, publish },
-    headers,
-    plugins: pluginsA,
-    redirects,
-  }
-}
-
-const keepPluginPublicProperties = function({ package, origin, inputs }) {
-  if (inputs === undefined) {
-    return { package, origin }
-  }
-
-  const inputsA = filterObj(inputs, isPublicInput)
-  return { package, origin, inputs: inputsA }
-}
-
-const isPublicInput = function(key, input) {
-  return typeof input === 'boolean'
-}
-
-// The resolved configuration gets assigned some default values (empty objects and arrays)
-// to make it more convenient to use without checking for `undefined`.
-// However those empty values are not useful to users, so we don't log them.
-const simplifyConfig = function({ build: { environment = {}, ...build }, plugins, ...netlifyConfig }) {
-  const environmentA = omit(environment, BUILDBOT_ENVIRONMENT)
-  const simplifiedBuild = removeFalsy({
-    ...build,
-    ...removeEmptyObject(environmentA, 'environment'),
-  })
-  return removeFalsy({
-    ...netlifyConfig,
-    ...removeEmptyObject(simplifiedBuild, 'build'),
-    ...removeEmptyArray(plugins, 'plugins'),
-  })
-}
-
-// Added by the buildbot. We only want to print environment variables specified
-// by the user.
-const BUILDBOT_ENVIRONMENT = [
-  'BRANCH',
-  'CONTEXT',
-  'DEPLOY_PRIME_URL',
-  'DEPLOY_URL',
-  'GO_VERSION',
-  'NETLIFY_IMAGES_CDN_DOMAIN',
-  'URL',
-]
-
-const removeEmptyObject = function(object, propName) {
-  return Object.keys(object).length === 0 ? {} : { [propName]: object }
-}
-
-const removeEmptyArray = function(array, propName) {
-  return array.length === 0 ? {} : { [propName]: array }
-}
-
-const logContext = function(context) {
-  if (context === undefined) {
-    return
-  }
-
-  logSubHeader('Context')
-  logMessage(context)
-}
-
-const logInstallMissingPlugins = function(packages) {
-  logSubHeader('Installing plugins')
-  logArray(packages)
-}
-
-const logMissingPluginsWarning = function(packages) {
-  logErrorSubHeader('Missing plugins')
-  logMessage(
-    THEME.errorSubHeader(
-      `The following plugins should be installed either via the Netlify app or as a "dependency" inside your project's "package.json"`,
-    ),
-  )
-  logArray(packages, { color: THEME.errorSubHeader })
-}
-
-const logInstallLocalPluginsDeps = function(localPluginsOptions) {
-  const packages = localPluginsOptions.map(getPackage)
-  logSubHeader('Installing local plugins dependencies')
-  logArray(packages)
-}
-
-const logDeprecatedLocalInstall = function() {
-  logErrorSubHeader('Missing plugin')
-  logMessage(
-    THEME.errorSubHeader(`Please use the plugin "@netlify/plugin-local-install-core" to install dependencies from the "package.json" inside your local plugins.
-Example "netlify.toml":
-
-  [[plugins]]
-  package = "@netlify/plugin-local-install-core"`),
-  )
-}
-
-const logInstallFunctionDependencies = function() {
-  log('Installing functions dependencies')
-}
-
-const logDeprecatedFunctionsInstall = function(functionsSrc) {
-  logErrorSubHeader('Missing plugin')
-  logMessage(
-    THEME.errorSubHeader(`Please use the plugin "@netlify/plugin-functions-install-core" to install dependencies from the "package.json" inside your "${functionsSrc}" directory.
-Example "netlify.toml":
-
-  [build]
-  functions = "${functionsSrc}"
-
-  [[plugins]]
-  package = "@netlify/plugin-functions-install-core"`),
-  )
-}
-
-const getPackage = function({ package }) {
-  return package
-}
-
-const logLoadingPlugins = function(pluginsOptions) {
-  const loadingPlugins = pluginsOptions.map(getPluginDescription)
-
-  if (loadingPlugins.length === 0) {
-    return
-  }
-
-  logSubHeader('Loading plugins')
-  logArray(loadingPlugins)
-}
-
-const getPluginDescription = function({ package, packageJson: { version }, loadedFrom, origin }) {
-  const versionA = version === undefined ? '' : `@${version}`
-  const pluginOrigin = getPluginOrigin(loadedFrom, origin)
-  return `${THEME.highlightWords(package)}${versionA} ${pluginOrigin}`
-}
-
-const logDryRunStart = function(eventWidth, commandsCount) {
-  const columnWidth = getDryColumnWidth(eventWidth, commandsCount)
-  const line = '─'.repeat(columnWidth)
-  const secondLine = '─'.repeat(columnWidth)
-
-  logSubHeader('Netlify Build Commands')
-  logMessage(`For more information on build events see the docs https://github.com/netlify/build
-
-Running \`netlify build\` will execute this build flow
-
-${THEME.header(`┌─${line}─┬─${secondLine}─┐
-│ ${DRY_HEADER_NAMES[0].padEnd(columnWidth)} │ ${DRY_HEADER_NAMES[1].padEnd(columnWidth)} │
-└─${line}─┴─${secondLine}─┘`)}`)
-}
-
-const logDryRunCommand = function({ command: { event, package }, index, configPath, eventWidth, commandsCount }) {
-  const columnWidth = getDryColumnWidth(eventWidth, commandsCount)
-  const line = '─'.repeat(columnWidth)
-  const countText = `${index + 1}. `
-  const downArrow = commandsCount === index + 1 ? '  ' : ` ${arrowDown}`
-  const eventWidthA = columnWidth - countText.length - downArrow.length
-  const fullName = getPluginFullName({ package, configPath })
-
-  logMessage(
-    `${THEME.header(`┌─${line}─┐`)}
-${THEME.header(`│ ${countText}${event.padEnd(eventWidthA)}${downArrow} │`)} ${fullName}
-${THEME.header(`└─${line}─┘ `)}`,
-  )
-}
-
-const getPluginFullName = function({ package, configPath }) {
-  if (package === undefined) {
-    return getBuildCommandDescription(configPath)
-  }
-
-  return `Plugin ${THEME.highlightWords(package)}`
-}
-
-const getDryColumnWidth = function(eventWidth, commandsCount) {
-  const symbolsWidth = `${commandsCount}`.length + 4
-  return Math.max(eventWidth + symbolsWidth, DRY_HEADER_NAMES[1].length)
-}
-
-const DRY_HEADER_NAMES = ['Event', 'Location']
-
-const logDryRunEnd = function() {
-  logMessage(`\nIf this looks good to you, run \`netlify build\` to execute the build\n`)
-}
-
-const logCommand = function({ event, package, index, configPath, error }) {
-  const description = getCommandDescription({ event, package, configPath })
-  const logHeaderFunc = error ? logErrorHeader : logHeader
-  logHeaderFunc(`${index + 1}. ${description}`)
-  logMessage('')
-}
-
-const logBuildCommandStart = function(buildCommand) {
-  log(THEME.highlightWords(`$ ${buildCommand}`))
-}
-
-const logCommandSuccess = function() {
-  logMessage('')
-}
-
-const logTimer = function(durationMs, timerName) {
-  const duration = prettyMs(durationMs)
-  log(THEME.dimWords(`(${timerName} completed in ${duration})`))
-}
-
-const logStatuses = function(statuses) {
-  logHeader('Summary')
-  statuses.forEach(logStatus)
-}
-
-const logStatus = function({ package, title = `Plugin ${package} ran successfully`, summary, text }) {
-  const titleA = title.includes(package) ? title : `${package}: ${title}`
-  const body = text === undefined ? summary : `${summary}\n${THEME.dimWords(text)}`
-  logSubHeader(titleA)
-  logMessage(body)
-}
-
-const logCacheDir = function(path) {
-  logMessage(`Caching ${path}`)
-}
-
-const logPluginError = function(error, netlifyConfig) {
-  const { title, body } = serializeLogError(error)
-  logErrorHeader(title)
-  logMessage(`\n${body}\n`)
-  logConfigOnError(netlifyConfig)
-}
-
-const logBuildError = function(error) {
-  const { title, body, isSuccess, netlifyConfig } = serializeLogError(error)
-  const logFunction = isSuccess ? logHeader : logErrorHeader
-  logFunction(title)
-  logMessage(`\n${body}\n`)
-  logConfigOnError(netlifyConfig)
-}
-
-const logBuildSuccess = function() {
-  logHeader('Netlify Build Complete')
-  logMessage('')
-}
-
-module.exports = {
-  logBuildStart,
-  logFlags,
-  logBuildDir,
-  logConfigPath,
-  logConfig,
-  logContext,
-  logInstallMissingPlugins,
-  logMissingPluginsWarning,
-  logInstallLocalPluginsDeps,
-  logDeprecatedLocalInstall,
-  logInstallFunctionDependencies,
-  logDeprecatedFunctionsInstall,
-  logLoadingPlugins,
-  logDryRunStart,
-  logDryRunCommand,
-  logDryRunEnd,
-  logCommand,
-  logBuildCommandStart,
-  logCommandSuccess,
-  logTimer,
-  logStatuses,
-  logCacheDir,
-  logPluginError,
-  logBuildError,
-  logBuildSuccess,
-}

package/src/log/old_version.js

@@ -1,45 +0,0 @@
-const {
-  env: { NETLIFY_BUILD_TEST },
-  stdout,
-} = require('process')
-
-const readPkgUp = require('read-pkg-up')
-const UpdateNotifier = require('update-notifier')
-
-// Many build errors happen in local builds that do not use the latest version
-// of `@netlify/build`. We print a warning message on those.
-// We only print this when Netlify CLI has been used. Programmatic usage might
-// come from a deep dependency calling `@netlify/build` and user might not be
-// able to take any upgrade action, making the message noisy.
-const logOldCliVersionError = async function(mode) {
-  if (mode !== 'cli') {
-    return
-  }
-
-  const pkg = await getPkg()
-  UpdateNotifier({ pkg, updateCheckInterval: 1 }).notify({
-    message: OLD_VERSION_MESSAGE,
-    shouldNotifyInNpmScript: true,
-  })
-}
-
-const getPkg = async function() {
-  const { packageJson } = await readPkgUp({ cwd: __dirname, normalize: false })
-
-  // TODO: Find a way to test this without injecting code in the `src/`
-  if (NETLIFY_BUILD_TEST) {
-    // `update-notifier` does not do anything if not in a TTY.
-    // In tests, we need to monkey patch this
-    stdout.isTTY = true
-
-    return { ...packageJson, version: '0.0.1' }
-  }
-
-  return packageJson
-}
-
-const OLD_VERSION_MESSAGE = `Please update netlify-cli to its latest version.
-If netlify-cli is already the latest version,
-please update your dependencies lock file instead.`
-
-module.exports = { logOldCliVersionError }

package/src/log/serialize.js

@@ -1,15 +0,0 @@
-const { dump, JSON_SCHEMA } = require('js-yaml')
-
-const serializeObject = function(object) {
-  return dump(object, { schema: JSON_SCHEMA, noRefs: true, sortKeys: true, lineWidth: Infinity }).trimRight()
-}
-
-const serializeArray = function(array) {
-  return array.map(addDash).join('\n')
-}
-
-const addDash = function(string) {
-  return ` - ${string}`
-}
-
-module.exports = { serializeObject, serializeArray }

package/src/log/stream.js

@@ -1,15 +0,0 @@
-const { stdout, stderr } = require('process')
-
-// Start streaming Bash command or plugin command output
-const pipeOutput = function(childProcess) {
-  childProcess.stdout.pipe(stdout)
-  childProcess.stderr.pipe(stderr)
-}
-
-// Stop streaming/buffering Bash command or plugin command output
-const unpipeOutput = function(childProcess) {
-  childProcess.stdout.unpipe(stdout)
-  childProcess.stderr.unpipe(stderr)
-}
-
-module.exports = { pipeOutput, unpipeOutput }

package/src/log/theme.js

@@ -1,32 +0,0 @@
-const {
-  cyanBright: { bold: cyanBrightBold },
-  cyan: { bold: cyanBold },
-  cyan,
-  redBright: { bold: redBrightBold },
-  red: { bold: redBold },
-  red,
-  gray,
-} = require('chalk')
-
-// Color theme. Please use this instead of requiring chalk directly, to ensure
-// consistent colors.
-const THEME = {
-  // Main headers
-  header: cyanBrightBold,
-  // Single lines used as subheaders
-  subHeader: cyanBold,
-  // Main headers indicating an error
-  errorHeader: redBrightBold,
-  // Single lines used as subheaders indicating an error
-  errorSubHeader: redBold,
-  // Non-headers indicating an error
-  errorLine: red,
-  // One of several words that should be highlighted inside a line
-  highlightWords: cyan,
-  // One of several words that should be dimmed inside a line
-  dimWords: gray,
-  // No colors
-  none: string => string,
-}
-
-module.exports = { THEME }

package/src/log/timer.js

@@ -1,28 +0,0 @@
-const { hrtime } = require('process')
-
-const { logTimer } = require('./main')
-
-// Starts a timer
-const startTimer = function() {
-  return hrtime()
-}
-
-// Stops a timer
-const endTimerDuration = function([startSecs, startNsecs]) {
-  const [endSecs, endNsecs] = hrtime()
-  const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs
-  const durationMs = Math.ceil(durationNs / NANOSECS_TO_MSECS)
-  return durationMs
-}
-
-// Ends a timer and prints the result on console
-const endTimer = function(hrTime, timerName) {
-  const durationMs = endTimerDuration(hrTime)
-  logTimer(durationMs, timerName)
-  return durationMs
-}
-
-const NANOSECS_TO_SECS = 1e9
-const NANOSECS_TO_MSECS = 1e6
-
-module.exports = { startTimer, endTimer }

package/src/plugins/child/api.js

@@ -1,59 +0,0 @@
-const {
-  env: { NETLIFY_BUILD_API_CLIENT },
-} = require('process')
-
-const NetlifyAPI = require('netlify')
-
-const { failBuild } = require('../error')
-
-// Retrieve Netlify API client, providing a authentication token was provided
-const getApiClient = function({ manifest: { scopes = DEFAULT_SCOPES }, token }) {
-  // This feature is not currently finished due to lack of API support
-  // See https://github.com/netlify/build/issues/585
-  if (NETLIFY_BUILD_API_CLIENT !== '1') {
-    return
-  }
-
-  if (!token) {
-    if (scopes.length !== 0) {
-      failBuild('This plugin requires a Netlify API authentication token')
-    }
-
-    return
-  }
-
-  const api = new NetlifyAPI(token)
-
-  disableApiMethods(api, scopes)
-
-  return api
-}
-
-const DEFAULT_SCOPES = []
-
-// Redact API methods to scopes
-const disableApiMethods = function(api, scopes) {
-  if (scopes.includes('*')) {
-    return
-  }
-
-  API_METHODS.filter(method => !scopes.includes(method)).forEach(method => {
-    api[method] = disabledApiMethod.bind(null, method)
-  })
-}
-
-const getApiMethods = function() {
-  return NetlifyAPI.methods.map(getApiMethod)
-}
-
-const getApiMethod = function({ operationId }) {
-  return operationId
-}
-
-const API_METHODS = getApiMethods()
-
-const disabledApiMethod = async function(method) {
-  failBuild(`This plugin is not authorized to use "api.${method}". Please update the plugin scopes.`)
-}
-
-module.exports = { getApiClient, API_METHODS }

package/src/plugins/child/error.js

@@ -1,39 +0,0 @@
-// eslint-disable-next-line import/order
-const logProcessErrors = require('log-process-errors')
-
-const { hasColors } = require('../../log/colors')
-const { isBuildError, ERROR_TYPE_SYM } = require('../error')
-const { sendEventToParent } = require('../ipc')
-
-// Handle any top-level error and communicate it back to parent
-const handleError = async function({
-  name,
-  message,
-  stack,
-  [ERROR_TYPE_SYM]: type = DEFAULT_ERROR_TYPE,
-  ...errorProps
-}) {
-  await sendEventToParent('error', { name, message, stack, type, errorProps })
-}
-
-const DEFAULT_ERROR_TYPE = 'pluginInternal'
-
-// On uncaught exceptions and unhandled rejections, print the stack trace.
-// Also, prevent child processes from crashing on uncaught exceptions.
-const handleProcessErrors = function() {
-  logProcessErrors({ log: handleProcessError, colors: hasColors(), exitOn: [], level: { multipleResolves: 'silent' } })
-}
-
-const handleProcessError = async function(error, level, originalError) {
-  if (level !== 'error') {
-    console[level](error)
-    return
-  }
-
-  // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
-  const errorA = isBuildError(originalError) ? originalError : error
-
-  await handleError(errorA)
-}
-
-module.exports = { handleError, handleProcessErrors }

package/src/plugins/child/load.js

@@ -1,40 +0,0 @@
-const { getApiClient } = require('./api')
-const { getLogic } = require('./logic')
-const { normalizePlugin } = require('./normalize')
-const { validatePlugin } = require('./validate')
-
-// Load context passed to every plugin method.
-// This also requires the plugin file and fire its top-level function.
-// This also validates the plugin.
-// Do it when parent requests it using the `load` event.
-// Also figure out the list of plugin commands. This is also passed to the parent.
-const load = function(payload) {
-  const logic = getLogic(payload)
-
-  validatePlugin(logic)
-
-  const logicA = normalizePlugin(logic)
-
-  const pluginCommands = getPluginCommands(logicA)
-
-  const context = getContext(pluginCommands, payload)
-  return { pluginCommands, context }
-}
-
-const getPluginCommands = function(logic) {
-  return Object.entries(logic)
-    .filter(isEventHandler)
-    .map(([event, method]) => ({ event, method }))
-}
-
-const isEventHandler = function([, value]) {
-  return typeof value === 'function'
-}
-
-// Retrieve context passed to every event handler
-const getContext = function(pluginCommands, { manifest, inputs, netlifyConfig, constants, utilsData, token }) {
-  const api = getApiClient({ manifest, token })
-  return { pluginCommands, api, utilsData, constants, inputs, netlifyConfig }
-}
-
-module.exports = { load }

package/src/plugins/child/logic.js

@@ -1,31 +0,0 @@
-// Require the plugin file and fire its top-level function.
-// The returned object is the `logic` which includes all event handlers.
-const getLogic = function({ pluginPath, inputs }) {
-  const logic = requireLogic(pluginPath)
-  const logicA = loadLogic({ logic, inputs })
-  return logicA
-}
-
-const requireLogic = function(pluginPath) {
-  try {
-    return require(pluginPath)
-  } catch (error) {
-    error.message = `Could not import plugin:\n${error.message}`
-    throw error
-  }
-}
-
-const loadLogic = function({ logic, inputs }) {
-  if (typeof logic !== 'function') {
-    return logic
-  }
-
-  try {
-    return logic(inputs)
-  } catch (error) {
-    error.message = `Could not load plugin:\n${error.message}`
-    throw error
-  }
-}
-
-module.exports = { getLogic }