@netlify/build 27.20.3 → 27.20.5

package/lib/plugins/manifest/load.js

@@ -1,41 +1,38 @@
-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'
-
+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
-  }
-}
-
+    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
-  }
-}
-
+    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}`)
-  }
-}
+    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/lib/plugins/manifest/main.js

@@ -1,22 +1,17 @@
-import { addPluginLoadErrorStatus } from '../../status/load_error.js'
-
-import { checkInputs } from './check.js'
-import { loadManifest } from './load.js'
-import { getManifestPath } from './path.js'
-
+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
-  }
-}
+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/lib/plugins/manifest/path.js

@@ -1,31 +1,24 @@
-import { locatePath } from 'locate-path'
-
-import { addErrorInfo } from '../../error/info.js'
-
+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 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".
+    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']
+  - 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/lib/plugins/manifest/validate.js

@@ -1,108 +1,91 @@
-import isPlainObj from 'is-plain-obj'
-
-import { THEME } from '../../log/theme.js'
-
+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}
+    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
-  }
-}
-
+${rawManifest.trim()}`;
+        throw error;
+    }
+};
 const validateBasic = function (manifest) {
-  if (!isPlainObj(manifest)) {
-    throw new Error('must be a plain object')
-  }
-}
-
+    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 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')
-  }
-}
-
+    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)
-}
-
+    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)
-}
-
+    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
-  }
-}
-
+    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 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')
-  }
-}
-
+    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')
-  }
-}
-
+    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')
-  }
-}
+    if (required !== undefined && typeof required !== 'boolean') {
+        throw new Error('"required" property must be a boolean');
+    }
+};

package/lib/plugins/node_version.js

@@ -1,50 +1,30 @@
-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'
-
+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 }
-}
-
+    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}`,
-    )
-  }
-}
-
+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
-}
+    const error = new Error(message);
+    addErrorInfo(error, { type: 'resolveConfig' });
+    throw error;
+};

package/lib/plugins/options.js

@@ -1,88 +1,55 @@
-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'
-
+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')
-
+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 }
-}
-
+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,
-    )
-  )
-}
-
+    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' },
-  }
-}
+    return {
+        plugin: { packageName: ROOT_PACKAGE_JSON.name, pluginPackageJson: ROOT_PACKAGE_JSON },
+        location: { event: 'load', packageName: ROOT_PACKAGE_JSON.name, loadedFrom: 'core', origin: 'core' },
+    };
+};