@netlify/build 29.0.1-rc → 29.0.2

package/src/plugins/manifest/check.js

@@ -1,106 +0,0 @@
-import { addErrorInfo } from '../../error/info.js'
-import { serializeObject } from '../../log/serialize.js'
-import { THEME } from '../../log/theme.js'
-
-// Check that plugin inputs match the validation specified in "manifest.yml"
-// Also assign default values
-export const checkInputs = function ({
-  inputs,
-  manifest: { inputs: rules = [] },
-  packageName,
-  pluginPackageJson,
-  loadedFrom,
-  origin,
-}) {
-  try {
-    const inputsA = addDefaults(inputs, rules)
-    checkRequiredInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin })
-    checkUnknownInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, 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, packageName, pluginPackageJson, 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 "${packageName}": ${names.join(', ')}`)
-  addInputError({ error, name: names[0], packageName, pluginPackageJson, 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 checkUnknownInputs = function ({ inputs, rules, packageName, pluginPackageJson, loadedFrom, origin }) {
-  const knownInputs = rules.map(getName)
-  const unknownInputs = Object.keys(inputs).filter((name) => !knownInputs.includes(name))
-  if (unknownInputs.length === 0) {
-    return
-  }
-
-  const unknownInputsMessage = getUnknownInputsMessage({ packageName, knownInputs, unknownInputs })
-  const error = new Error(`${unknownInputsMessage}
-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`)
-  const [name] = unknownInputs
-  addInputError({ error, name, packageName, pluginPackageJson, loadedFrom, origin })
-  throw error
-}
-
-const getUnknownInputsMessage = function ({ packageName, knownInputs, unknownInputs }) {
-  const unknownInputsStr = unknownInputs.map(quoteWord).join(', ')
-
-  if (knownInputs.length === 0) {
-    return `Plugin "${packageName}" does not accept any inputs but you specified: ${unknownInputsStr}`
-  }
-
-  const knownInputsStr = knownInputs.map(quoteWord).join(', ')
-  return `Unknown inputs for plugin "${packageName}": ${unknownInputsStr}
-Plugin inputs should be one of: ${knownInputsStr}`
-}
-
-const quoteWord = function (word) {
-  return `"${word}"`
-}
-
-// Add error information
-const addInputError = function ({ error, name, packageName, pluginPackageJson, loadedFrom, origin }) {
-  addErrorInfo(error, {
-    type: 'pluginInput',
-    plugin: { packageName, pluginPackageJson },
-    location: { event: 'load', packageName, input: name, loadedFrom, origin },
-  })
-}

package/src/plugins/manifest/load.js

@@ -1,41 +0,0 @@
-import { promises as fs } from 'fs'
-
-import { load as loadYaml, JSON_SCHEMA } from 'js-yaml'
-
-import { addErrorInfo } from '../../error/info.js'
-
-import { validateManifest } from './validate.js'
-
-// Load "manifest.yml" using its file path
-export const loadManifest = async function ({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin }) {
-  try {
-    const rawManifest = await loadRawManifest(manifestPath)
-    const manifest = await parseManifest(rawManifest)
-    validateManifest(manifest, rawManifest)
-    return manifest
-  } catch (error) {
-    addErrorInfo(error, {
-      type: 'pluginValidation',
-      plugin: { packageName, pluginPackageJson },
-      location: { event: 'load', packageName, loadedFrom, origin },
-    })
-    throw error
-  }
-}
-
-const loadRawManifest = async function (manifestPath) {
-  try {
-    return await fs.readFile(manifestPath, 'utf8')
-  } catch (error) {
-    error.message = `Could not load plugin's "manifest.yml"\n${error.message}`
-    throw error
-  }
-}
-
-const parseManifest = async function (rawManifest) {
-  try {
-    return await loadYaml(rawManifest, { schema: JSON_SCHEMA, json: true })
-  } catch (error) {
-    throw new Error(`Could not parse plugin's "manifest.yml"\n${error.message}`)
-  }
-}

package/src/plugins/manifest/main.js

@@ -1,22 +0,0 @@
-import { addPluginLoadErrorStatus } from '../../status/load_error.js'
-
-import { checkInputs } from './check.js'
-import { loadManifest } from './load.js'
-import { getManifestPath } from './path.js'
-
-// Load plugin's `manifest.yml`
-export const useManifest = async function (
-  { packageName, loadedFrom, origin, inputs },
-  { pluginDir, packageDir, pluginPackageJson, pluginPackageJson: { version }, debug },
-) {
-  const manifestPath = await getManifestPath({ pluginDir, packageDir, packageName })
-
-  try {
-    const manifest = await loadManifest({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin })
-    const inputsA = checkInputs({ inputs, manifest, packageName, pluginPackageJson, loadedFrom, origin })
-    return { manifest, inputs: inputsA }
-  } catch (error) {
-    addPluginLoadErrorStatus({ error, packageName, version, debug })
-    throw error
-  }
-}

package/src/plugins/manifest/path.js

@@ -1,31 +0,0 @@
-import { locatePath } from 'locate-path'
-
-import { addErrorInfo } from '../../error/info.js'
-
-// Retrieve "manifest.yml" path for a specific plugin
-export const getManifestPath = async function ({ pluginDir, packageDir, packageName }) {
-  const dirs = [pluginDir, packageDir]
-    .filter(Boolean)
-    .flatMap((dir) => MANIFEST_FILENAMES.map((filename) => `${dir}/${filename}`))
-  const manifestPath = await locatePath(dirs)
-  validateManifestExists(manifestPath, packageName)
-  return manifestPath
-}
-
-const validateManifestExists = function (manifestPath, packageName) {
-  if (manifestPath !== undefined) {
-    return
-  }
-
-  const error = new Error(
-    `The plugin "${packageName}" is missing a "manifest.yml".
-This might mean:
-  - The plugin "package" name is misspelled
-  - The plugin "package" points to a Node module that is not a Netlify Build plugin
-  - If you're developing a plugin, please see the documentation at https://docs.netlify.com/configure-builds/build-plugins/create-plugins/#anatomy-of-a-plugin`,
-  )
-  addErrorInfo(error, { type: 'resolveConfig' })
-  throw error
-}
-
-const MANIFEST_FILENAMES = ['manifest.yml', 'manifest.yaml']

package/src/plugins/manifest/validate.js

@@ -1,108 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-
-import { THEME } from '../../log/theme.js'
-
-// Validate `manifest.yml` syntax
-export const validateManifest = function (manifest, rawManifest) {
-  try {
-    validateBasic(manifest)
-    validateUnknownProps(manifest)
-    validateName(manifest)
-    validateInputs(manifest)
-  } catch (error) {
-    error.message = `Plugin's "manifest.yml" ${error.message}
-
-${THEME.errorSubHeader('manifest.yml')}
-${rawManifest.trim()}`
-    throw error
-  }
-}
-
-const validateBasic = function (manifest) {
-  if (!isPlainObj(manifest)) {
-    throw new Error('must be a plain object')
-  }
-}
-
-const validateUnknownProps = function (manifest) {
-  const unknownProp = Object.keys(manifest).find((key) => !VALID_PROPS.has(key))
-  if (unknownProp !== undefined) {
-    throw new Error(`unknown property "${unknownProp}"`)
-  }
-}
-
-const VALID_PROPS = new Set(['name', 'inputs'])
-
-const validateName = function ({ name }) {
-  if (name === undefined) {
-    throw new Error('must contain a "name" property')
-  }
-
-  if (typeof name !== 'string') {
-    throw new TypeError('"name" property must be a string')
-  }
-}
-
-const validateInputs = function ({ inputs }) {
-  if (inputs === undefined) {
-    return
-  }
-
-  if (!isArrayOfObjects(inputs)) {
-    throw new Error('"inputs" property must be an array of objects')
-  }
-
-  inputs.forEach(validateInput)
-}
-
-const isArrayOfObjects = function (objects) {
-  return Array.isArray(objects) && objects.every(isPlainObj)
-}
-
-const validateInput = function (input, index) {
-  try {
-    validateUnknownInputProps(input)
-    validateInputName(input)
-    validateInputDescription(input)
-    validateInputRequired(input)
-  } catch (error) {
-    error.message = `"inputs" property is invalid.
-Input at position ${index} ${error.message}.`
-    throw error
-  }
-}
-
-const validateUnknownInputProps = function (input) {
-  const unknownProp = Object.keys(input).find((key) => !VALID_INPUT_PROPS.has(key))
-  if (unknownProp !== undefined) {
-    throw new Error(`has an unknown property "${unknownProp}"`)
-  }
-}
-
-const VALID_INPUT_PROPS = new Set(['name', 'description', 'required', 'default'])
-
-const validateInputName = function ({ name }) {
-  if (name === undefined) {
-    throw new Error('must contain a "name" property')
-  }
-
-  if (typeof name !== 'string') {
-    throw new TypeError('"name" property must be a string')
-  }
-}
-
-const validateInputDescription = function ({ description }) {
-  if (description === undefined) {
-    return
-  }
-
-  if (typeof description !== 'string') {
-    throw new TypeError('"description" property must be a string')
-  }
-}
-
-const validateInputRequired = function ({ required }) {
-  if (required !== undefined && typeof required !== 'boolean') {
-    throw new Error('"required" property must be a boolean')
-  }
-}

package/src/plugins/node_version.js

@@ -1,50 +0,0 @@
-import { version as currentVersion, execPath } from 'process'
-
-import semver from 'semver'
-
-import { addErrorInfo } from '../error/info.js'
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
-// Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum
-// supported version. Else default to the system Node version.
-// Local and programmatic builds use `@netlify/build` Node.js version, which is
-// usually the system's Node.js version.
-// If the user Node version does not satisfy our supported engine range use our own system Node version
-export const addPluginsNodeVersion = function ({ pluginsOptions, nodePath, userNodeVersion }) {
-  const currentNodeVersion = semver.clean(currentVersion)
-  return pluginsOptions.map((pluginOptions) =>
-    addPluginNodeVersion({ pluginOptions, currentNodeVersion, userNodeVersion, nodePath }),
-  )
-}
-
-const addPluginNodeVersion = function ({
-  pluginOptions,
-  pluginOptions: { loadedFrom },
-  currentNodeVersion,
-  userNodeVersion,
-  nodePath,
-}) {
-  return (loadedFrom === 'local' || loadedFrom === 'package.json') &&
-    semver.satisfies(userNodeVersion, ROOT_PACKAGE_JSON.engines.node)
-    ? { ...pluginOptions, nodePath, nodeVersion: userNodeVersion }
-    : { ...pluginOptions, nodePath: execPath, nodeVersion: currentNodeVersion }
-}
-
-// Ensure Node.js version is compatible with plugin's `engines.node`
-export const checkNodeVersion = function ({
-  nodeVersion,
-  packageName,
-  pluginPackageJson: { engines: { node: pluginNodeVersionRange } = {} } = {},
-}) {
-  if (pluginNodeVersionRange && !semver.satisfies(nodeVersion, pluginNodeVersionRange)) {
-    throwUserError(
-      `The Node.js version is ${nodeVersion} but the plugin "${packageName}" requires ${pluginNodeVersionRange}`,
-    )
-  }
-}
-
-const throwUserError = function (message) {
-  const error = new Error(message)
-  addErrorInfo(error, { type: 'resolveConfig' })
-  throw error
-}

package/src/plugins/options.js

@@ -1,88 +0,0 @@
-import { dirname } from 'path'
-
-import { installLocalPluginsDependencies } from '../install/local.js'
-import { measureDuration } from '../time/main.js'
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-import { getPackageJson } from '../utils/package.js'
-
-import { useManifest } from './manifest/main.js'
-import { checkNodeVersion } from './node_version.js'
-import { resolvePluginsPath } from './resolve.js'
-
-// Load core plugins and user plugins
-const tGetPluginsOptions = async function ({
-  pluginsOptions,
-  netlifyConfig: { plugins },
-  siteInfo,
-  buildDir,
-  nodePath,
-  packageJson,
-  userNodeVersion,
-  mode,
-  api,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-  featureFlags,
-}) {
-  const pluginsOptionsA = await resolvePluginsPath({
-    pluginsOptions,
-    siteInfo,
-    buildDir,
-    nodePath,
-    packageJson,
-    userNodeVersion,
-    mode,
-    api,
-    logs,
-    debug,
-    sendStatus,
-    testOpts,
-    featureFlags,
-  })
-  const pluginsOptionsB = await Promise.all(
-    pluginsOptionsA.map((pluginOptions) => loadPluginFiles({ pluginOptions, debug })),
-  )
-  const pluginsOptionsC = pluginsOptionsB.filter(isNotRedundantCorePlugin)
-  await installLocalPluginsDependencies({ plugins, pluginsOptions: pluginsOptionsC, buildDir, mode, logs })
-  return { pluginsOptions: pluginsOptionsC }
-}
-
-export const getPluginsOptions = measureDuration(tGetPluginsOptions, 'get_plugins_options')
-
-// Retrieve plugin's main file path.
-// Then load plugin's `package.json` and `manifest.yml`.
-const loadPluginFiles = async function ({
-  pluginOptions,
-  pluginOptions: { pluginPath, nodeVersion, packageName },
-  debug,
-}) {
-  const pluginDir = dirname(pluginPath)
-  const { packageDir, packageJson: pluginPackageJson } = await getPackageJson(pluginDir)
-  checkNodeVersion({ nodeVersion, packageName, pluginPackageJson })
-  const { manifest, inputs } = await useManifest(pluginOptions, { pluginDir, packageDir, pluginPackageJson, debug })
-  return { ...pluginOptions, pluginDir, packageDir, pluginPackageJson, manifest, inputs }
-}
-
-// Core plugins can only be included once.
-// For example, when testing core plugins, they might be included as local plugins,
-// in which case they should not be included twice.
-const isNotRedundantCorePlugin = function (pluginOptionsA, index, pluginsOptions) {
-  return (
-    pluginOptionsA.loadedFrom !== 'core' ||
-    pluginsOptions.every(
-      (pluginOptionsB) =>
-        pluginOptionsA.manifest.name !== pluginOptionsB.manifest.name || pluginOptionsA === pluginOptionsB,
-    )
-  )
-}
-
-// Retrieve information about @netlify/build when an error happens there and not
-// in a plugin
-export const getSpawnInfo = function () {
-  return {
-    plugin: { packageName: ROOT_PACKAGE_JSON.name, pluginPackageJson: ROOT_PACKAGE_JSON },
-    location: { event: 'load', packageName: ROOT_PACKAGE_JSON.name, loadedFrom: 'core', origin: 'core' },
-  }
-}

package/src/plugins/pinned_version.js

@@ -1,131 +0,0 @@
-import { handleBuildError } from '../error/handle.js'
-import { getMajorVersion } from '../utils/semver.js'
-
-// Retrieve plugin's pinned major versions by fetching the latest `PluginRun`
-// Only applies to `netlify.toml`-only installed plugins.
-export const addPinnedVersions = async function ({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }) {
-  if (!sendStatus || api === undefined || !siteId) {
-    return pluginsOptions
-  }
-
-  const packages = pluginsOptions.filter(shouldFetchPinVersion).map(getPackageName)
-  if (packages.length === 0) {
-    return pluginsOptions
-  }
-
-  const pluginRuns = await api.getLatestPluginRuns({ site_id: siteId, packages, state: 'success' })
-  const pluginsOptionsA = pluginsOptions.map((pluginOption) => addPinnedVersion(pluginOption, pluginRuns))
-  return pluginsOptionsA
-}
-
-const shouldFetchPinVersion = function ({ pinnedVersion, loadedFrom, origin }) {
-  return pinnedVersion === undefined && loadedFrom === 'auto_install' && origin === 'config'
-}
-
-const getPackageName = function ({ packageName }) {
-  return packageName
-}
-
-const addPinnedVersion = function (pluginOptions, pluginRuns) {
-  const foundPluginRun = pluginRuns.find((pluginRun) => pluginRun.package === pluginOptions.packageName)
-  if (foundPluginRun === undefined) {
-    return pluginOptions
-  }
-
-  const pinnedVersion = getMajorVersion(foundPluginRun.version)
-  return pinnedVersion === undefined ? pluginOptions : { ...pluginOptions, pinnedVersion }
-}
-
-// Send an API request to pin plugins' major versions.
-// Only applies to UI-installed plugins.
-export const pinPlugins = async function ({
-  pluginsOptions,
-  failedPlugins,
-  api,
-  siteInfo: { id: siteId },
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  logs,
-  debug,
-  testOpts,
-  sendStatus,
-}) {
-  if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !siteId) {
-    return
-  }
-
-  const pluginsOptionsA = pluginsOptions.filter((pluginOptions) => shouldPinVersion({ pluginOptions, failedPlugins }))
-  await Promise.all(
-    pluginsOptionsA.map((pluginOptions) =>
-      pinPlugin({
-        pluginOptions,
-        api,
-        childEnv,
-        mode,
-        netlifyConfig,
-        errorMonitor,
-        logs,
-        debug,
-        testOpts,
-        siteId,
-      }),
-    ),
-  )
-}
-
-// Only pin version if:
-//  - the plugin's version has not been pinned yet
-//  - the plugin was installed in the UI
-//  - both the build and the plugin succeeded
-const shouldPinVersion = function ({
-  pluginOptions: { packageName, pinnedVersion, loadedFrom, origin },
-  failedPlugins,
-}) {
-  return (
-    pinnedVersion === undefined &&
-    loadedFrom === 'auto_install' &&
-    origin === 'ui' &&
-    !failedPlugins.includes(packageName)
-  )
-}
-
-const pinPlugin = async function ({
-  pluginOptions: {
-    packageName,
-    pluginPackageJson: { version },
-  },
-  api,
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  logs,
-  debug,
-  testOpts,
-  siteId,
-}) {
-  const pinnedVersion = getMajorVersion(version)
-  try {
-    await api.updatePlugin({
-      package: encodeURIComponent(packageName),
-      site_id: siteId,
-      body: { pinned_version: pinnedVersion },
-    })
-    // Bitballoon API randomly fails with 502.
-    // Builds should be successful when this API call fails, but we still want
-    // to report the error both in logs and in error monitoring.
-  } catch (error) {
-    if (shouldIgnoreError(error)) {
-      return
-    }
-
-    await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
-  }
-}
-
-// Status is 404 if the plugin is uninstalled while the build is ongoing.
-const shouldIgnoreError = function ({ status }) {
-  return status === 404
-}