@netlify/build 0.4.48 → 1.0.0-dl-test

package/src/plugins/child/main.js

@@ -1,48 +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()
-
-const { sendEventToParent, getEventsFromParent } = require('../ipc')
-
-const { handleProcessErrors, handleError } = require('./error')
-const { load } = require('./load')
-const { run } = require('./run')
-
-// Boot plugin child process.
-const bootPlugin = async function() {
-  try {
-    handleProcessErrors()
-
-    const state = {}
-    // 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')])
-  } catch (error) {
-    await handleError(error)
-  }
-}
-
-// 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) {
-  try {
-    const { context, ...response } = await EVENTS[eventName](payload, state.context)
-    state.context = { ...state.context, ...context }
-    await sendEventToParent(callId, response)
-  } catch (error) {
-    await handleError(error)
-  }
-}
-
-const EVENTS = { load, run }
-
-bootPlugin()

package/src/plugins/child/normalize.js

@@ -1,20 +0,0 @@
-const mapObj = require('map-obj')
-
-const { LEGACY_EVENTS } = require('../events')
-
-// Normalize plugin shape
-const normalizePlugin = function(logic) {
-  return mapObj(logic, normalizeProperty)
-}
-
-const normalizeProperty = function(key, value) {
-  const newKey = LEGACY_EVENTS[key]
-
-  if (newKey === undefined) {
-    return [key, value]
-  }
-
-  return [newKey, value]
-}
-
-module.exports = { normalizePlugin }

package/src/plugins/child/run.js

@@ -1,34 +0,0 @@
-const { getNewEnvChanges, setEnvChanges } = require('../../env/changes.js')
-
-const { getUtils } = require('./utils')
-
-// Run a specific plugin event handler
-const run = async function(
-  { event, error, envChanges },
-  { pluginCommands, api, utilsData, constants, inputs, netlifyConfig },
-) {
-  const { method } = pluginCommands.find(pluginCommand => pluginCommand.event === event)
-  const runState = {}
-  const utils = getUtils({ utilsData, constants, runState })
-  const runOptions = { api, utils, constants, inputs, netlifyConfig, error }
-  addBackwardCompatibility(runOptions)
-
-  const envBefore = setEnvChanges(envChanges)
-  await method(runOptions)
-  const newEnvChanges = getNewEnvChanges(envBefore)
-  return { ...runState, newEnvChanges }
-}
-
-// Add older names, kept for backward compatibility. Non-enumerable.
-// TODO: remove after being out of beta
-const addBackwardCompatibility = function(runOptions) {
-  Object.defineProperties(runOptions, {
-    pluginConfig: { value: runOptions.inputs },
-  })
-  // Make `constants.BUILD_DIR` non-enumerable
-  Object.defineProperty(runOptions.constants, 'BUILD_DIR', {
-    value: runOptions.constants.BUILD_DIR,
-  })
-}
-
-module.exports = { run }

package/src/plugins/child/status.js

@@ -1,53 +0,0 @@
-const isPlainObj = require('is-plain-obj')
-
-const { ERROR_TYPE_SYM } = require('../error')
-
-// Retrieve `utils.status.*` methods
-const getStatusUtil = function(runState) {
-  return { show: show.bind(undefined, runState) }
-}
-
-// Report status information to the UI
-const show = function(runState, showArgs) {
-  validateShowArgs(showArgs)
-  const { title, summary, text } = showArgs
-  runState.status = { state: 'success', title, summary, text }
-}
-
-// Validate arguments of `utils.status.show()`
-const validateShowArgs = function(showArgs) {
-  try {
-    if (showArgs === undefined) {
-      throw new Error('requires an argument')
-    }
-
-    if (!isPlainObj(showArgs)) {
-      throw new Error('argument must be a plain object')
-    }
-
-    const { title, summary, text, ...otherArgs } = showArgs
-    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(', ')}`)
-    }
-
-    if (summary === undefined) {
-      throw new Error('requires specifying a "summary" property')
-    }
-
-    Object.entries({ title, summary, text }).forEach(validateStringArg)
-  } catch (error) {
-    error.message = `utils.status.show() ${error.message}`
-    error[ERROR_TYPE_SYM] = 'pluginValidation'
-    throw error
-  }
-}
-
-const validateStringArg = function([key, value]) {
-  if (value !== undefined && (typeof value !== 'string' || value.trim() === '')) {
-    throw new Error(`"${key}" property must be a non-empty string`)
-  }
-}
-
-module.exports = { getStatusUtil }

package/src/plugins/child/utils.js

@@ -1,43 +0,0 @@
-const cacheUtils = require('@netlify/cache-utils')
-const functionsUtils = require('@netlify/functions-utils')
-const gitUtils = require('@netlify/git-utils')
-const runUtils = require('@netlify/run-utils')
-
-const { failBuild, failPlugin, cancelBuild } = require('../error')
-
-const { getStatusUtil } = require('./status')
-
-// Some utilities need to perform some async initialization logic first.
-// We do it once for all plugins in the parent process then pass it to the child
-// processes.
-const startUtils = async function(buildDir) {
-  const git = await gitUtils({ cwd: buildDir })
-  return { git }
-}
-
-// Retrieve the `utils` argument.
-const getUtils = function({ utilsData: { git }, constants: { FUNCTIONS_SRC, CACHE_DIR }, runState }) {
-  const buildUtils = { failBuild, failPlugin, cancelBuild }
-  const gitA = gitUtils.load(git)
-  const cache = cacheUtils.bindOpts({ cacheDir: CACHE_DIR })
-  const add = src => functionsUtils.add(src, FUNCTIONS_SRC, { fail: failBuild })
-  const functions = { add }
-  const status = getStatusUtil(runState)
-  const utils = {
-    build: buildUtils,
-    git: gitA,
-    cache,
-    run: runUtils,
-    functions,
-    status,
-  }
-
-  // Older names, kept for backward compatibility. Non-enumerable.
-  // TODO: remove after beta is done
-  Object.defineProperty(utils.build, 'fail', { value: utils.build.failBuild })
-  Object.defineProperty(utils.build, 'cancel', { value: utils.build.cancelBuild })
-
-  return utils
-}
-
-module.exports = { startUtils, getUtils }

package/src/plugins/child/validate.js

@@ -1,46 +0,0 @@
-const isPlainObj = require('is-plain-obj')
-
-const { serializeArray } = require('../../log/serialize')
-const { ERROR_TYPE_SYM } = require('../error')
-const { EVENTS, LEGACY_EVENTS } = require('../events')
-
-// Validate the shape of a plugin return value
-const validatePlugin = function(logic) {
-  try {
-    if (!isPlainObj(logic)) {
-      throw new Error('Plugin must be an object or a function')
-    }
-
-    Object.entries(logic).forEach(([propName, value]) => validateProperty(value, propName))
-  } catch (error) {
-    error[ERROR_TYPE_SYM] = 'pluginValidation'
-    throw error
-  }
-}
-
-const validateProperty = function(value, propName) {
-  if (DEPRECATED_PROPERTIES.includes(propName)) {
-    return
-  }
-
-  // All other properties are event handlers
-  validateEventHandler(value, propName)
-}
-
-// Backward compatibility. This is now in manifest.yml
-// TODO: remove after migrating existing plugins
-const DEPRECATED_PROPERTIES = ['name', 'inputs', 'config', 'scopes']
-
-const validateEventHandler = function(value, propName) {
-  if (!EVENTS.includes(propName) && LEGACY_EVENTS[propName] === undefined) {
-    throw new Error(`Invalid event '${propName}'.
-Please use a valid event name. One of:
-${serializeArray(EVENTS)}`)
-  }
-
-  if (typeof value !== 'function') {
-    throw new Error(`Invalid event handler '${propName}': must be a function`)
-  }
-}
-
-module.exports = { validatePlugin }

package/src/plugins/error.js

@@ -1,44 +0,0 @@
-// Stop build.
-// As opposed to throwing an error directly or to uncaught exceptions, this is
-// displayed as a user error, not an implementation error.
-const failBuild = function(message, opts) {
-  throw normalizeError('failBuild', failBuild, message, opts)
-}
-
-// Stop plugin. Same as `failBuild` but only stops plugin not whole build
-const failPlugin = function(message, opts) {
-  throw normalizeError('failPlugin', failPlugin, message, opts)
-}
-
-// Cancel build. Same as `failBuild` except it marks the build as "canceled".
-const cancelBuild = function(message, opts) {
-  throw normalizeError('cancelBuild', cancelBuild, message, opts)
-}
-
-// An `error` option can be passed to keep the original error message and
-// stack trace. An additional `message` string is always required.
-const normalizeError = function(type, func, message, { error } = {}) {
-  const errorA = getError(error, message, func)
-  errorA[ERROR_TYPE_SYM] = type
-  return errorA
-}
-
-const getError = function(error, message, func) {
-  if (error instanceof Error) {
-    error.message = `${message}\n${error.message}`
-    return error
-  }
-
-  const errorA = new Error(message)
-  // Do not include function itself in the stack trace
-  Error.captureStackTrace(errorA, func)
-  return errorA
-}
-
-const isBuildError = function(error) {
-  return error instanceof Error && error[ERROR_TYPE_SYM] !== undefined
-}
-
-const ERROR_TYPE_SYM = Symbol('errorType')
-
-module.exports = { failBuild, failPlugin, cancelBuild, isBuildError, ERROR_TYPE_SYM }

package/src/plugins/events.js

@@ -1,77 +0,0 @@
-const EVENTS = [
-  /**
-   * `onPreBuild` - Before build commands are executed
-   */
-  'onPreBuild',
-  /**
-   * `onBuild` - Build commands are executed
-   */
-  'onBuild',
-  /**
-   * `onPostBuild` - After Build commands are executed
-   */
-  'onPostBuild',
-
-  /**
-   * `onSuccess` - Runs on build success
-   */
-  'onSuccess',
-  /**
-   * `onError` - Runs on build error
-   */
-  'onError',
-  /**
-   * `onEnd` - Runs on build error or success
-   */
-  'onEnd',
-]
-
-// TODO: remove after going out of beta
-const LEGACY_EVENTS = {
-  init: 'onPreBuild',
-  onInit: 'onPreBuild',
-  preBuild: 'onPreBuild',
-  preGetCache: 'onPreBuild',
-  onPreGetCache: 'onPreBuild',
-  getCache: 'onPreBuild',
-  onGetCache: 'onPreBuild',
-  postGetCache: 'onPreBuild',
-  onPostGetCache: 'onPreBuild',
-  preInstall: 'onPreBuild',
-  onPreInstall: 'onPreBuild',
-  install: 'onPreBuild',
-  onInstall: 'onPreBuild',
-  postInstall: 'onPreBuild',
-  onPostInstall: 'onPreBuild',
-  build: 'onBuild',
-  postBuild: 'onPostBuild',
-  preFunctionsBuild: 'onPostBuild',
-  onPreFunctionsBuild: 'onPostBuild',
-  functionsBuild: 'onPostBuild',
-  onFunctionsBuild: 'onPostBuild',
-  postFunctionsBuild: 'onPostBuild',
-  onPostFunctionsBuild: 'onPostBuild',
-  preFunctionsPackage: 'onPostBuild',
-  onPreFunctionsPackage: 'onPostBuild',
-  functionsPackage: 'onPostBuild',
-  onFunctionsPackage: 'onPostBuild',
-  postFunctionsPackage: 'onPostBuild',
-  onPostFunctionsPackage: 'onPostBuild',
-  prePackage: 'onPostBuild',
-  package: 'onPostBuild',
-  postPackage: 'onPostBuild',
-  preDeploy: 'onPostBuild',
-  onPreDeploy: 'onPostBuild',
-  preSaveCache: 'onPostBuild',
-  onPreSaveCache: 'onPostBuild',
-  saveCache: 'onPostBuild',
-  onSaveCache: 'onPostBuild',
-  postSaveCache: 'onPostBuild',
-  onPostSaveCache: 'onPostBuild',
-  success: 'onSuccess',
-  error: 'onError',
-  end: 'onEnd',
-  finally: 'onEnd',
-}
-
-module.exports = { EVENTS, LEGACY_EVENTS }

package/src/plugins/ipc.js

@@ -1,136 +0,0 @@
-const { promisify } = require('util')
-
-const pEvent = require('p-event')
-const { v4: uuidv4 } = require('uuid')
-
-const { buildError } = require('../error/build')
-const { addErrorInfo } = require('../error/info')
-
-// Send event from child to parent process then wait for response
-// We need to fire them in parallel because `process.send()` can be slow
-// to await, i.e. child might send response before parent start listening for it
-const callChild = async function(childProcess, eventName, payload, { plugin, location }) {
-  const callId = uuidv4()
-  const [response] = await Promise.all([
-    getEventFromChild(childProcess, callId, { plugin, location }),
-    sendEventToChild(childProcess, callId, eventName, payload),
-  ])
-  return response
-}
-
-// Receive event from child to parent process
-// Wait for either:
-//  - `message` event with a specific `callId`
-//  - `message` event with an `error` `callId` indicating an exception in the
-//    child process
-//  - child process `exit`
-// In the later two cases, we propagate the error.
-// We need to make `p-event` listeners are properly cleaned up too.
-const getEventFromChild = async function(childProcess, callId, { plugin, location }) {
-  if (!childProcess.connected) {
-    const error = new Error(`Could not receive event from child process because it already exited.
-${EXIT_WARNING}`)
-    addErrorInfo(error, { type: 'ipc', plugin, location })
-    throw error
-  }
-
-  const messagePromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === callId })
-  const errorPromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === 'error' })
-  const exitPromise = pEvent(childProcess, 'exit', { multiArgs: true })
-  try {
-    return await Promise.race([
-      getMessage(messagePromise),
-      getError(errorPromise, { plugin, location }),
-      getExit(exitPromise, { plugin, location }),
-    ])
-  } finally {
-    messagePromise.cancel()
-    errorPromise.cancel()
-    exitPromise.cancel()
-  }
-}
-
-const getMessage = async function(messagePromise) {
-  const [, response] = await messagePromise
-  return response
-}
-
-const getError = async function(errorPromise, { plugin, location }) {
-  const [, { errorProps, ...values }] = await errorPromise
-  throw buildError({ ...values, ...errorProps, plugin, location })
-}
-
-const getExit = async function(exitPromise, { plugin, location }) {
-  const [exitCode, signal] = await exitPromise
-  const error = new Error(`Plugin exited with exit code ${exitCode} and signal ${signal}.
-${EXIT_WARNING}`)
-  addErrorInfo(error, { type: 'ipc', plugin, location })
-  throw error
-}
-
-// Plugins should not terminate processes explicitly:
-//  - It prevents specifying error messages to the end users
-//  - It makes it impossible to distinguish between bugs (such as infinite loops) and user errors
-//  - It complicates child process orchestration. For example if an async operation
-//    of a previous event handler is still running, it would be aborted if another
-//    is terminating the process.
-const EXIT_WARNING = `The plugin might have exited due to a bug terminating the process, such as an infinite loop.
-The plugin might also have explicitly terminated the process, for example with process.exit().
-Plugin methods should instead:
-  - on success: return
-  - on failure: call utils.build.failPlugin() or utils.build.failBuild()`
-
-// Send event from parent to child process
-const sendEventToChild = async function(childProcess, callId, eventName, payload) {
-  const payloadA = serializePayload(payload)
-  await promisify(childProcess.send.bind(childProcess))([callId, eventName, payloadA])
-}
-
-// Respond to events from parent to child process.
-// This runs forever until `childProcess.kill()` is called.
-const getEventsFromParent = async function(callback) {
-  return new Promise((resolve, reject) => {
-    process.on('message', async message => {
-      try {
-        const [callId, eventName, payload] = message
-        const payloadA = parsePayload(payload)
-        await callback(callId, eventName, payloadA)
-      } catch (error) {
-        reject(error)
-      }
-    })
-  })
-}
-
-// Send event from child to parent process
-const sendEventToParent = async function(callId, payload) {
-  await promisify(process.send.bind(process))([callId, payload])
-}
-
-// Errors are not serializable through `child_process` `ipc` so we need to
-// convert from/to plain objects.
-// TODO: use `child_process.spawn()` `serialization: 'advanced'` option after
-// dropping support for Node.js <=13.2.0
-const serializePayload = function({ error: { name, message, stack, ...errorProps } = {}, ...payload }) {
-  if (name === undefined) {
-    return payload
-  }
-
-  return { ...payload, error: { ...errorProps, name, message, stack } }
-}
-
-const parsePayload = function({ error = {}, ...payload }) {
-  if (error.name === undefined) {
-    return payload
-  }
-
-  const errorA = buildError(error)
-  return { ...payload, error: errorA }
-}
-
-module.exports = {
-  callChild,
-  getEventFromChild,
-  getEventsFromParent,
-  sendEventToParent,
-}

package/src/plugins/load.js

@@ -1,66 +0,0 @@
-const { reportPluginLoadError } = require('../status/report')
-
-const { callChild } = require('./ipc')
-
-// Retrieve all plugins commands
-// Can use either a module name or a file path to the plugin.
-const loadPlugins = async function({
-  pluginsOptions,
-  childProcesses,
-  netlifyConfig,
-  utilsData,
-  token,
-  constants,
-  mode,
-  api,
-}) {
-  const pluginsCommands = await Promise.all(
-    pluginsOptions.map((pluginOptions, index) =>
-      loadPlugin(pluginOptions, {
-        childProcesses,
-        index,
-        netlifyConfig,
-        utilsData,
-        token,
-        constants,
-        mode,
-        api,
-      }),
-    ),
-  )
-  const pluginsCommandsA = pluginsCommands.flat()
-  return pluginsCommandsA
-}
-
-// Retrieve plugin commands for one plugin.
-// Do it by executing the plugin `load` event handler.
-const loadPlugin = async function(
-  { package, packageJson, packageJson: { version } = {}, pluginPath, manifest, inputs, loadedFrom, origin },
-  { childProcesses, index, netlifyConfig, utilsData, token, constants, mode, api },
-) {
-  const { childProcess } = childProcesses[index]
-  const event = 'load'
-
-  try {
-    const { pluginCommands } = await callChild(
-      childProcess,
-      'load',
-      { pluginPath, manifest, inputs, netlifyConfig, utilsData, token, constants },
-      { plugin: { package, packageJson }, location: { event, package, loadedFrom, origin } },
-    )
-    const pluginCommandsA = pluginCommands.map(({ event }) => ({
-      event,
-      package,
-      loadedFrom,
-      origin,
-      packageJson,
-      childProcess,
-    }))
-    return pluginCommandsA
-  } catch (error) {
-    await reportPluginLoadError({ error, api, mode, event, package, version })
-    throw error
-  }
-}
-
-module.exports = { loadPlugins }

package/src/plugins/manifest/check.js

@@ -1,80 +0,0 @@
-const { addErrorInfo } = require('../../error/info')
-const { serializeObject } = require('../../log/serialize')
-const { THEME } = require('../../log/theme')
-
-// Check that plugin inputs match the validation specified in "manifest.yml"
-// Also assign default values
-const checkInputs = function({ inputs, manifest: { inputs: rules = [] }, package, packageJson, loadedFrom, origin }) {
-  try {
-    const inputsA = addDefaults(inputs, rules)
-    checkRequiredInputs({ inputs: inputsA, rules, package, packageJson, loadedFrom, origin })
-    Object.keys(inputsA).map(name => checkInput({ name, rules, package, packageJson, loadedFrom, origin }))
-    return inputsA
-  } catch (error) {
-    error.message = `${error.message}
-
-${THEME.errorSubHeader('Plugin inputs')}
-${serializeObject(inputs)}`
-    throw error
-  }
-}
-
-// Add "inputs[*].default"
-const addDefaults = function(inputs, rules) {
-  const defaults = rules.filter(hasDefault).map(getDefault)
-  return Object.assign({}, ...defaults, inputs)
-}
-
-const hasDefault = function(rule) {
-  return rule.default !== undefined
-}
-
-const getDefault = function({ name, default: defaultValue }) {
-  return { [name]: defaultValue }
-}
-
-// Check "inputs[*].required"
-const checkRequiredInputs = function({ inputs, rules, package, packageJson, loadedFrom, origin }) {
-  const missingInputs = rules.filter(rule => isMissingRequired(inputs, rule))
-  if (missingInputs.length === 0) {
-    return
-  }
-
-  const names = missingInputs.map(getName)
-  const error = new Error(`Required inputs for plugin "${package}": ${names.join(', ')}`)
-  addInputError({ error, name: names[0], package, packageJson, loadedFrom, origin })
-  throw error
-}
-
-const isMissingRequired = function(inputs, { name, required }) {
-  return required && inputs[name] === undefined
-}
-
-const getName = function({ name }) {
-  return name
-}
-
-// Check each "inputs[*].*" property for a specific input
-const checkInput = function({ name, rules, package, packageJson, loadedFrom, origin }) {
-  const ruleA = rules.find(rule => rule.name === name)
-  if (ruleA === undefined) {
-    const error = new Error(`Invalid input "${name}" for plugin "${package}".
-Check your plugin configuration to be sure that:
-  - the input name is spelled correctly
-  - the input is included in the plugin's available configuration options
-  - the plugin's input requirements have not changed`)
-    addInputError({ error, name, package, packageJson, loadedFrom, origin })
-    throw error
-  }
-}
-
-// Add error information
-const addInputError = function({ error, name, package, packageJson, loadedFrom, origin }) {
-  addErrorInfo(error, {
-    type: 'pluginInput',
-    plugin: { package, packageJson },
-    location: { event: 'load', package, input: name, loadedFrom, origin },
-  })
-}
-
-module.exports = { checkInputs }