@netlify/build 29.0.1-rc → 29.0.2

package/src/log/messages/ipc.js

@@ -1,38 +0,0 @@
-import { log } from '../logger.js'
-
-const logVerbose = function (logs, verbose, message) {
-  if (!verbose) {
-    return
-  }
-
-  log(logs, message)
-}
-
-export const logSendingEventToChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step starting.')
-}
-
-export const logSentEventToChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step started.')
-}
-
-export const logPluginMethodStart = function (verbose) {
-  logVerbose(undefined, verbose, 'Plugin logic started.')
-}
-
-export const logPluginMethodEnd = function (verbose) {
-  logVerbose(undefined, verbose, 'Plugin logic ended.')
-}
-
-export const logSendingEventToParent = function (verbose, error) {
-  const message = error instanceof Error ? `Step erroring.\n${error.stack}` : 'Stop closing.'
-  logVerbose(undefined, verbose, message)
-}
-
-export const logReceivedEventFromChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step ended.')
-}
-
-export const logStepCompleted = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step completed.')
-}

package/src/log/messages/mutations.js

@@ -1,82 +0,0 @@
-import { promises as fs } from 'fs'
-import { inspect } from 'util'
-
-import { pathExists } from 'path-exists'
-
-import { log, logMessage, logSubHeader } from '../logger.js'
-
-export const logConfigMutations = function (logs, newConfigMutations, debug) {
-  const configMutationsToLog = debug ? newConfigMutations : newConfigMutations.filter(shouldLogConfigMutation)
-  configMutationsToLog.forEach(({ keysString, value }) => {
-    logConfigMutation(logs, keysString, value)
-  })
-}
-
-// Some configuration mutations are only logged in debug mode
-const shouldLogConfigMutation = function ({ keysString }) {
-  return !HIDDEN_PROPS.some((hiddenProp) => keysString.startsWith(hiddenProp))
-}
-
-// `functions` is an object which can have thousands of properties, one per
-// function file. This can be very verbose, especially for plugins which create
-// many function files like Essential Next.js
-const HIDDEN_PROPS = ['functions']
-
-const logConfigMutation = function (logs, keysString, value) {
-  const newValue = shouldHideConfigValue(keysString) ? '' : ` to ${inspect(value, { colors: false })}`
-  log(logs, `Netlify configuration property "${keysString}" value changed${newValue}.`)
-}
-
-const shouldHideConfigValue = function (keysString) {
-  return SECRET_PROPS.some((secretProp) => keysString.startsWith(secretProp))
-}
-
-const SECRET_PROPS = ['build.environment']
-
-export const logConfigOnUpload = async function ({ logs, configPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded config')
-
-  if (!(await pathExists(configPath))) {
-    logMessage(logs, 'No netlify.toml')
-    return
-  }
-
-  const configContents = await fs.readFile(configPath, 'utf8')
-  logMessage(logs, configContents.trim())
-}
-
-export const logHeadersOnUpload = async function ({ logs, headersPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded headers')
-
-  if (!(await pathExists(headersPath))) {
-    logMessage(logs, 'No headers')
-    return
-  }
-
-  const headersContents = await fs.readFile(headersPath, 'utf8')
-  logMessage(logs, headersContents.trim())
-}
-
-export const logRedirectsOnUpload = async function ({ logs, redirectsPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded redirects')
-
-  if (!(await pathExists(redirectsPath))) {
-    logMessage(logs, 'No redirects\n')
-    return
-  }
-
-  const redirectsContents = await fs.readFile(redirectsPath, 'utf8')
-  logMessage(logs, `${redirectsContents.trim()}\n`)
-}

package/src/log/messages/status.js

@@ -1,16 +0,0 @@
-import { logMessage, logHeader, logSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logStatuses = function (logs, statuses) {
-  logHeader(logs, 'Summary')
-  statuses.forEach((status) => {
-    logStatus(logs, status)
-  })
-}
-
-const logStatus = function (logs, { packageName, title = `Plugin ${packageName} ran successfully`, summary, text }) {
-  const titleA = title.includes(packageName) ? title : `${packageName}: ${title}`
-  const body = text === undefined ? summary : `${summary}\n${THEME.dimWords(text)}`
-  logSubHeader(logs, titleA)
-  logMessage(logs, body)
-}

package/src/log/messages/steps.js

@@ -1,22 +0,0 @@
-import { getLogHeaderFunc } from '../header_func.js'
-import { log, logMessage } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logStepStart = function ({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig }) {
-  const description = getDescription({ coreStepDescription, netlifyConfig, packageName, event })
-  const logHeaderFunc = getLogHeaderFunc(error)
-  logHeaderFunc(logs, `${index + 1}. ${description}`)
-  logMessage(logs, '')
-}
-
-const getDescription = function ({ coreStepDescription, netlifyConfig, packageName, event }) {
-  return coreStepDescription === undefined ? `${packageName} (${event} event)` : coreStepDescription({ netlifyConfig })
-}
-
-export const logBuildCommandStart = function (logs, buildCommand) {
-  log(logs, THEME.highlightWords(`$ ${buildCommand}`))
-}
-
-export const logStepSuccess = function (logs) {
-  logMessage(logs, '')
-}

package/src/log/old_version.js

@@ -1,41 +0,0 @@
-import { stdout } from 'process'
-
-import UpdateNotifier from 'update-notifier'
-
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
-// 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.
-export const logOldCliVersionError = function ({ mode, testOpts }) {
-  if (mode !== 'cli') {
-    return
-  }
-
-  const corePackageJson = getCorePackageJson(testOpts)
-  UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
-    message: OLD_VERSION_MESSAGE,
-    shouldNotifyInNpmScript: true,
-  })
-}
-
-const getCorePackageJson = function (testOpts) {
-  // TODO: Find a way to test this without injecting code in the `src/`
-  if (testOpts.oldCliLogs) {
-    // `update-notifier` does not do anything if not in a TTY.
-    // In tests, we need to monkey patch this
-    // Mutation is required due to how `stdout.isTTY` works
-    // eslint-disable-next-line fp/no-mutation
-    stdout.isTTY = true
-
-    return { ...ROOT_PACKAGE_JSON, version: '0.0.1' }
-  }
-
-  return ROOT_PACKAGE_JSON
-}
-
-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.`

package/src/log/serialize.js

@@ -1,13 +0,0 @@
-import { dump } from 'js-yaml'
-
-export const serializeObject = function (object) {
-  return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd()
-}
-
-export const serializeArray = function (array) {
-  return array.map(addDash).join('\n')
-}
-
-const addDash = function (string) {
-  return ` - ${string}`
-}

package/src/log/stream.js

@@ -1,85 +0,0 @@
-import { stdout, stderr } from 'process'
-import { promisify } from 'util'
-
-// TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
-// We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
-// which solves many problems. However we can only do it in build.command.
-// Plugins have several events, so need to be switch on and off instead.
-// In buffer mode (`logs` not `undefined`), `pipe` is necessary.
-export const getBuildCommandStdio = function (logs) {
-  if (logs !== undefined) {
-    return 'pipe'
-  }
-
-  return 'inherit'
-}
-
-// Add build command output
-export const handleBuildCommandOutput = function ({ stdout: commandStdout, stderr: commandStderr }, logs) {
-  if (logs === undefined) {
-    return
-  }
-
-  pushBuildCommandOutput(commandStdout, logs.stdout)
-  pushBuildCommandOutput(commandStderr, logs.stderr)
-}
-
-const pushBuildCommandOutput = function (output, logsArray) {
-  if (output === '') {
-    return
-  }
-
-  logsArray.push(output)
-}
-
-// Start plugin step output
-export const pipePluginOutput = function (childProcess, logs) {
-  if (logs === undefined) {
-    return streamOutput(childProcess)
-  }
-
-  return pushOutputToLogs(childProcess, logs)
-}
-
-// Stop streaming/buffering plugin step output
-export const unpipePluginOutput = async function (childProcess, logs, listeners) {
-  // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
-  await pSetTimeout(0)
-
-  if (logs === undefined) {
-    return unstreamOutput(childProcess)
-  }
-
-  unpushOutputToLogs(childProcess, logs, listeners)
-}
-
-// Usually, we stream stdout/stderr because it is more efficient
-const streamOutput = function (childProcess) {
-  childProcess.stdout.pipe(stdout)
-  childProcess.stderr.pipe(stderr)
-}
-
-const unstreamOutput = function (childProcess) {
-  childProcess.stdout.unpipe(stdout)
-  childProcess.stderr.unpipe(stderr)
-}
-
-// In tests, we push to the `logs` array instead
-const pushOutputToLogs = function (childProcess, logs) {
-  const stdoutListener = logsListener.bind(null, logs.stdout)
-  const stderrListener = logsListener.bind(null, logs.stderr)
-  childProcess.stdout.on('data', stdoutListener)
-  childProcess.stderr.on('data', stderrListener)
-  return { stdoutListener, stderrListener }
-}
-
-const logsListener = function (logs, chunk) {
-  logs.push(chunk.toString().trimEnd())
-}
-
-const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
-  childProcess.stdout.removeListener('data', stdoutListener)
-  childProcess.stderr.removeListener('data', stderrListener)
-}

package/src/log/theme.js

@@ -1,26 +0,0 @@
-import chalk from 'chalk'
-
-// Color theme. Please use this instead of requiring chalk directly, to ensure
-// consistent colors.
-export const THEME = {
-  // Main headers
-  header: chalk.cyanBright.bold,
-  // Single lines used as subheaders
-  subHeader: chalk.cyan.bold,
-  // One of several words that should be highlighted inside a line
-  highlightWords: chalk.cyan,
-  // Same for errors
-  errorHeader: chalk.redBright.bold,
-  errorSubHeader: chalk.red.bold,
-  errorLine: chalk.redBright,
-  errorHighlightWords: chalk.redBright.bold,
-  // Same for warnings
-  warningHeader: chalk.yellowBright.bold,
-  warningSubHeader: chalk.yellow.bold,
-  warningLine: chalk.yellowBright,
-  warningHighlightWords: chalk.yellowBright.bold,
-  // One of several words that should be dimmed inside a line
-  dimWords: chalk.gray,
-  // No colors
-  none: (string) => string,
-}

package/src/plugins/child/diff.js

@@ -1,55 +0,0 @@
-import { isDeepStrictEqual } from 'util'
-
-import isPlainObj from 'is-plain-obj'
-import rfdc from 'rfdc'
-
-const clone = rfdc()
-
-// Copy `netlifyConfig` so we can compare before/after mutating it
-export const cloneNetlifyConfig = function (netlifyConfig) {
-  return clone(netlifyConfig)
-}
-
-// Diff `netlifyConfig` before and after mutating it to retrieve an array of
-// `configMutations` objects.
-// We need to keep track of the changes on `netlifyConfig` so they can be
-// processed later to:
-//  - Warn plugin authors when mutating read-only properties
-//  - Apply the change to `netlifyConfig` in the parent process so it can
-//    run `@netlify/config` to normalize and validate the new values
-// `configMutations` is passed to parent process as JSON
-export const getConfigMutations = function (netlifyConfig, netlifyConfigCopy, event) {
-  const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, [])
-  return configMutations.map((configMutation) => getConfigMutation(configMutation, event))
-}
-
-// We only recurse over plain objects, not arrays. Which means array properties
-// can only be modified all at once.
-const diffObjects = function (objA, objB, parentKeys) {
-  const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])]
-  return allKeys.flatMap((key) => {
-    const valueA = objA[key]
-    const valueB = objB[key]
-    const keys = [...parentKeys, key]
-
-    if (isPlainObj(valueA) && isPlainObj(valueB)) {
-      return diffObjects(valueA, valueB, keys)
-    }
-
-    if (isDeepStrictEqual(valueA, valueB)) {
-      return []
-    }
-
-    return [{ keys, value: valueB }]
-  })
-}
-
-const getConfigMutation = function ({ keys, value }, event) {
-  const serializedKeys = keys.map(String)
-  return {
-    keys: serializedKeys,
-    keysString: serializedKeys.join('.'),
-    value,
-    event,
-  }
-}

package/src/plugins/child/error.js

@@ -1,32 +0,0 @@
-import logProcessErrors from 'log-process-errors'
-
-import { errorToJson } from '../../error/build.js'
-import { addDefaultErrorInfo, isBuildError } from '../../error/info.js'
-import { normalizeError } from '../../error/parse/normalize.js'
-import { sendEventToParent } from '../ipc.js'
-
-// Handle any top-level error and communicate it back to parent
-export const handleError = async function (error, verbose) {
-  const errorA = normalizeError(error)
-  addDefaultErrorInfo(errorA, { type: 'pluginInternal' })
-  const errorPayload = errorToJson(errorA)
-  await sendEventToParent('error', errorPayload, verbose, errorA)
-}
-
-// On uncaught exceptions and unhandled rejections, print the stack trace.
-// Also, prevent child processes from crashing on uncaught exceptions.
-export const handleProcessErrors = function () {
-  logProcessErrors({ log: handleProcessError, exitOn: [] })
-}
-
-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)
-}

package/src/plugins/child/lazy.js

@@ -1,18 +0,0 @@
-import memoizeOne from 'memoize-one'
-
-// Add a `object[propName]` whose value is the return value of `getFunc()`, but
-// is only retrieved when accessed.
-export const addLazyProp = function (object, propName, getFunc) {
-  const mGetFunc = memoizeOne(getFunc, returnTrue)
-  // Mutation is required due to the usage of `Object.defineProperty()`
-  // eslint-disable-next-line fp/no-mutating-methods
-  Object.defineProperty(object, propName, {
-    get: mGetFunc,
-    enumerable: true,
-    configurable: true,
-  })
-}
-
-const returnTrue = function () {
-  return true
-}

package/src/plugins/child/load.js

@@ -1,29 +0,0 @@
-import filterObj from 'filter-obj'
-
-import { getLogic } from './logic.js'
-import { registerTypeScript } from './typescript.js'
-import { validatePlugin } from './validate.js'
-
-// 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 steps. This is also passed to the parent.
-export const load = async function ({ pluginPath, inputs, packageJson, verbose }) {
-  const tsNodeService = registerTypeScript(pluginPath)
-  const logic = await getLogic({ pluginPath, inputs, tsNodeService })
-
-  validatePlugin(logic)
-
-  const methods = filterObj(logic, isEventHandler)
-  const events = Object.keys(methods)
-
-  // Context passed to every event handler
-  const context = { methods, inputs, packageJson, verbose }
-
-  return { events, context }
-}
-
-const isEventHandler = function (event, value) {
-  return typeof value === 'function'
-}

package/src/plugins/child/logic.js

@@ -1,57 +0,0 @@
-import { createRequire } from 'module'
-import { pathToFileURL } from 'url'
-
-import { addTsErrorInfo } from './typescript.js'
-
-const require = createRequire(import.meta.url)
-
-// Require the plugin file and fire its top-level function.
-// The returned object is the `logic` which includes all event handlers.
-export const getLogic = async function ({ pluginPath, inputs, tsNodeService }) {
-  const logic = await importLogic(pluginPath, tsNodeService)
-  const logicA = loadLogic({ logic, inputs })
-  return logicA
-}
-
-const importLogic = async function (pluginPath, tsNodeService) {
-  try {
-    // `ts-node` is not available programmatically for pure ES modules yet,
-    // which is currently making it impossible for local plugins to use both
-    // pure ES modules and TypeScript.
-    if (tsNodeService !== undefined) {
-      // eslint-disable-next-line import/no-dynamic-require
-      return require(pluginPath)
-    }
-
-    // `pluginPath` is an absolute file path but `import()` needs URLs.
-    // Converting those with `pathToFileURL()` is needed especially on Windows
-    // where the drive letter would not work with `import()`.
-    const returnValue = await import(pathToFileURL(pluginPath))
-    // Plugins should use named exports, but we still support default exports
-    // for backward compatibility with CommonJS
-    return returnValue.default === undefined ? returnValue : returnValue.default
-  } catch (error) {
-    addTsErrorInfo(error, tsNodeService)
-    // We must change `error.stack` instead of `error.message` because some
-    // errors thrown from `import()` access `error.stack` before throwing.
-    // `error.stack` is lazily instantiated by Node.js, so changing
-    // `error.message` afterwards would not modify `error.stack`. Therefore, the
-    // resulting stack trace, which is printed in the build logs, would not
-    // include the additional message prefix.
-    error.stack = `Could not import plugin:\n${error.stack}`
-    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
-  }
-}

package/src/plugins/child/main.js

@@ -1,51 +0,0 @@
-import { setInspectColors } from '../../log/colors.js'
-import { sendEventToParent, getEventsFromParent } from '../ipc.js'
-
-import { handleProcessErrors, handleError } from './error.js'
-import { load } from './load.js'
-import { run } from './run.js'
-
-// Boot plugin child process.
-const bootPlugin = async function () {
-  const state = { context: { verbose: false } }
-
-  try {
-    handleProcessErrors()
-    setInspectColors()
-
-    // We need to fire them in parallel because `process.send()` can be slow
-    // to await, i.e. parent might send `load` event before child `ready` event
-    // returns.
-    await Promise.all([handleEvents(state), sendEventToParent('ready', {}, false)])
-  } catch (error) {
-    await handleError(error, state.context.verbose)
-  }
-}
-
-// Wait for events from parent to perform plugin methods
-const handleEvents = async function (state) {
-  await getEventsFromParent((callId, eventName, payload) => handleEvent({ callId, eventName, payload, state }))
-}
-
-// Each event can pass `context` information to the next event
-const handleEvent = async function ({
-  callId,
-  eventName,
-  payload,
-  state,
-  state: {
-    context: { verbose },
-  },
-}) {
-  try {
-    const { context, ...response } = await EVENTS[eventName](payload, state.context)
-    state.context = { ...state.context, ...context }
-    await sendEventToParent(callId, response, verbose)
-  } catch (error) {
-    await handleError(error, verbose)
-  }
-}
-
-const EVENTS = { load, run }
-
-bootPlugin()

package/src/plugins/child/run.js

@@ -1,28 +0,0 @@
-import { getNewEnvChanges, setEnvChanges } from '../../env/changes.js'
-import { logPluginMethodStart, logPluginMethodEnd } from '../../log/messages/ipc.js'
-
-import { cloneNetlifyConfig, getConfigMutations } from './diff.js'
-import { getUtils } from './utils.js'
-
-// Run a specific plugin event handler
-export const run = async function (
-  { event, error, constants, envChanges, netlifyConfig },
-  { methods, inputs, packageJson, verbose },
-) {
-  const method = methods[event]
-  const runState = {}
-  const utils = getUtils({ event, constants, runState })
-  const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig)
-  const runOptions = { utils, constants, inputs, netlifyConfig: netlifyConfigCopy, packageJson, error }
-
-  const envBefore = setEnvChanges(envChanges)
-
-  logPluginMethodStart(verbose)
-  await method(runOptions)
-  logPluginMethodEnd(verbose)
-
-  const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy)
-
-  const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event)
-  return { ...runState, newEnvChanges, configMutations }
-}

package/src/plugins/child/status.js

@@ -1,74 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { addErrorInfo } from '../../error/info.js'
-
-// Report status information to the UI
-export const show = function (runState, showArgs) {
-  validateShowArgs(showArgs)
-  const { title, summary, text, extraData } = removeEmptyStrings(showArgs)
-  runState.status = { state: 'success', title, summary, text, extraData }
-}
-
-// Validate arguments of `utils.status.show()`
-const validateShowArgs = function (showArgs) {
-  try {
-    validateShowArgsObject(showArgs)
-    const { title, summary, text, extraData, ...otherArgs } = showArgs
-    validateShowArgsKeys(otherArgs)
-    Object.entries({ title, summary, text }).forEach(validateStringArg)
-    validateShowArgsSummary(summary)
-    validateShowArgsExtraData(extraData)
-  } catch (error) {
-    error.message = `utils.status.show() ${error.message}`
-    addErrorInfo(error, { type: 'pluginValidation' })
-    throw error
-  }
-}
-
-const validateShowArgsObject = function (showArgs) {
-  if (showArgs === undefined) {
-    throw new Error('requires an argument')
-  }
-
-  if (!isPlainObj(showArgs)) {
-    throw new Error('argument must be a plain object')
-  }
-}
-
-const validateShowArgsKeys = function (otherArgs) {
-  const otherKeys = Object.keys(otherArgs).map((arg) => `"${arg}"`)
-  if (otherKeys.length !== 0) {
-    throw new Error(`must only contain "title", "summary" or "text" properties, not ${otherKeys.join(', ')}`)
-  }
-}
-
-const validateStringArg = function ([key, value]) {
-  if (value !== undefined && typeof value !== 'string') {
-    throw new Error(`"${key}" property must be a string`)
-  }
-}
-
-const validateShowArgsSummary = function (summary) {
-  if (summary === undefined || summary.trim() === '') {
-    throw new Error('requires specifying a "summary" property')
-  }
-}
-
-const validateShowArgsExtraData = function (extraData) {
-  if (extraData !== undefined && Array.isArray(extraData) === false) {
-    throw new TypeError('provided extra data must be an array')
-  }
-}
-
-const removeEmptyStrings = function (showArgs) {
-  return mapObj(showArgs, removeEmptyString)
-}
-
-const removeEmptyString = function (key, value) {
-  if (typeof value === 'string' && value.trim() === '') {
-    return [key]
-  }
-
-  return [key, value]
-}