@netlify/build 28.0.1-beta → 28.1.0-framework-version-detection

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
-}

package/src/plugins/resolve.js

@@ -1,152 +0,0 @@
-import { addErrorInfo } from '../error/info.js'
-import { installMissingPlugins } from '../install/missing.js'
-import { resolvePath, tryResolvePath } from '../utils/resolve.js'
-
-import { addExpectedVersions } from './expected_version.js'
-import { addPluginsNodeVersion } from './node_version.js'
-import { addPinnedVersions } from './pinned_version.js'
-
-// Try to find plugins in four places, by priority order:
-//  - already loaded (core plugins)
-//  - local plugin
-//  - external plugin already installed in `node_modules`, most likely through `package.json`
-//  - automatically installed by us, to `.netlify/plugins/`
-export const resolvePluginsPath = async function ({
-  pluginsOptions,
-  siteInfo,
-  buildDir,
-  nodePath,
-  packageJson,
-  userNodeVersion,
-  mode,
-  api,
-  logs,
-  debug,
-  sendStatus,
-  testOpts,
-  featureFlags,
-}) {
-  const autoPluginsDir = getAutoPluginsDir(buildDir)
-  const pluginsOptionsA = await Promise.all(
-    pluginsOptions.map((pluginOptions) => resolvePluginPath({ pluginOptions, buildDir, autoPluginsDir })),
-  )
-  const pluginsOptionsB = addPluginsNodeVersion({
-    pluginsOptions: pluginsOptionsA,
-    nodePath,
-    userNodeVersion,
-    logs,
-  })
-  const pluginsOptionsC = await addPinnedVersions({ pluginsOptions: pluginsOptionsB, api, siteInfo, sendStatus })
-  const pluginsOptionsD = await addExpectedVersions({
-    pluginsOptions: pluginsOptionsC,
-    autoPluginsDir,
-    packageJson,
-    debug,
-    logs,
-    buildDir,
-    testOpts,
-    featureFlags,
-  })
-  const pluginsOptionsE = await handleMissingPlugins({
-    pluginsOptions: pluginsOptionsD,
-    autoPluginsDir,
-    mode,
-    logs,
-  })
-  return pluginsOptionsE
-}
-
-// Find the path to the directory used to install plugins automatically.
-// It is a subdirectory of `buildDir`, so that the plugin can require the
-// project's dependencies (peer dependencies).
-const getAutoPluginsDir = function (buildDir) {
-  return `${buildDir}/${AUTO_PLUGINS_DIR}`
-}
-
-const AUTO_PLUGINS_DIR = '.netlify/plugins/'
-
-const resolvePluginPath = async function ({
-  pluginOptions,
-  pluginOptions: { packageName, loadedFrom },
-  buildDir,
-  autoPluginsDir,
-}) {
-  // Core plugins
-  if (loadedFrom !== undefined) {
-    return pluginOptions
-  }
-
-  const localPackageName = normalizeLocalPackageName(packageName)
-
-  // Local plugins
-  if (localPackageName.startsWith('.')) {
-    const { path: localPath, error } = await tryResolvePath(localPackageName, buildDir)
-    validateLocalPluginPath(error, localPackageName)
-    return { ...pluginOptions, pluginPath: localPath, loadedFrom: 'local' }
-  }
-
-  // Plugin added to `package.json`
-  const { path: manualPath } = await tryResolvePath(packageName, buildDir)
-  if (manualPath !== undefined) {
-    return { ...pluginOptions, pluginPath: manualPath, loadedFrom: 'package.json' }
-  }
-
-  // Previously automatically installed
-  const { path: automaticPath } = await tryResolvePath(packageName, autoPluginsDir)
-  if (automaticPath !== undefined) {
-    return { ...pluginOptions, pluginPath: automaticPath, loadedFrom: 'auto_install' }
-  }
-
-  // Happens if the plugin:
-  //  - name is mispelled
-  //  - is not in our official list
-  //  - is in our official list but has not been installed by this site yet
-  return { ...pluginOptions, loadedFrom: 'auto_install' }
-}
-
-// `packageName` starting with `/` are relative to the build directory
-const normalizeLocalPackageName = function (packageName) {
-  if (packageName.startsWith('/')) {
-    return `.${packageName}`
-  }
-
-  return packageName
-}
-
-// When requiring a local plugin with an invalid file path
-const validateLocalPluginPath = function (error, localPackageName) {
-  if (error !== undefined) {
-    error.message = `Plugin could not be found using local path: ${localPackageName}\n${error.message}`
-    addErrorInfo(error, { type: 'resolveConfig' })
-    throw error
-  }
-}
-
-// Install plugins from the official list that have not been previously installed.
-// Print a warning if they have not been installed through the UI.
-const handleMissingPlugins = async function ({ pluginsOptions, autoPluginsDir, mode, logs }) {
-  const missingPlugins = pluginsOptions.filter(isMissingPlugin)
-
-  if (missingPlugins.length === 0) {
-    return pluginsOptions
-  }
-
-  await installMissingPlugins({ missingPlugins, autoPluginsDir, mode, logs })
-  return await Promise.all(
-    pluginsOptions.map((pluginOptions) => resolveMissingPluginPath({ pluginOptions, autoPluginsDir })),
-  )
-}
-
-// Resolve the plugins that just got automatically installed
-const resolveMissingPluginPath = async function ({ pluginOptions, pluginOptions: { packageName }, autoPluginsDir }) {
-  if (!isMissingPlugin(pluginOptions)) {
-    return pluginOptions
-  }
-
-  const pluginPath = await resolvePath(packageName, autoPluginsDir)
-  return { ...pluginOptions, pluginPath }
-}
-
-const isMissingPlugin = function ({ isMissing }) {
-  return isMissing
-}

package/src/plugins/spawn.js

@@ -1,66 +0,0 @@
-import { fileURLToPath } from 'url'
-
-import { execaNode } from 'execa'
-
-import { addErrorInfo } from '../error/info.js'
-import { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } from '../log/messages/compatibility.js'
-import { measureDuration } from '../time/main.js'
-
-import { getEventFromChild } from './ipc.js'
-import { getSpawnInfo } from './options.js'
-
-const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url))
-
-// Start child processes used by all plugins
-// We fire plugins through child processes so that:
-//  - each plugin is sandboxed, e.g. cannot access/modify its parent `process`
-//    (for both security and safety reasons)
-//  - logs can be buffered which allows manipulating them for log shipping,
-//    transforming and parallel plugins
-const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs, debug }) {
-  logLoadingPlugins(logs, pluginsOptions, debug)
-  logOutdatedPlugins(logs, pluginsOptions)
-  logIncompatiblePlugins(logs, pluginsOptions)
-
-  const childProcesses = await Promise.all(
-    pluginsOptions.map(({ pluginDir, nodePath }) => startPlugin({ pluginDir, nodePath, buildDir, childEnv })),
-  )
-  return { childProcesses }
-}
-
-export const startPlugins = measureDuration(tStartPlugins, 'start_plugins')
-
-const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv }) {
-  const childProcess = execaNode(CHILD_MAIN_FILE, {
-    cwd: buildDir,
-    preferLocal: true,
-    localDir: pluginDir,
-    nodePath,
-    execPath: nodePath,
-    env: childEnv,
-    extendEnv: false,
-    serialization: 'advanced',
-  })
-
-  try {
-    await getEventFromChild(childProcess, 'ready')
-    return { childProcess }
-  } catch (error) {
-    const spawnInfo = getSpawnInfo()
-    addErrorInfo(error, spawnInfo)
-    throw error
-  }
-}
-
-// Stop all plugins child processes
-export const stopPlugins = function (childProcesses) {
-  childProcesses.forEach(stopPlugin)
-}
-
-const stopPlugin = function ({ childProcess }) {
-  if (childProcess.connected) {
-    childProcess.disconnect()
-  }
-
-  childProcess.kill()
-}