@netlify/build 27.20.4 → 27.20.6

package/lib/plugins/compatibility.js

@@ -1,10 +1,8 @@
-import pEvery from 'p-every'
-import pLocate from 'p-locate'
-import semver from 'semver'
-
-import { importJsonFile } from '../utils/json.js'
-import { resolvePath } from '../utils/resolve.js'
-
+import pEvery from 'p-every';
+import pLocate from 'p-locate';
+import semver from 'semver';
+import { importJsonFile } from '../utils/json.js';
+import { resolvePath } from '../utils/resolve.js';
 // Retrieve the `expectedVersion` of a plugin:
 //  - This is the version which should be run
 //  - This takes version pinning into account
@@ -15,17 +13,16 @@ import { resolvePath } from '../utils/resolve.js'
 //  - This is only used to print a warning message when the `compatibleVersion`
 //    is older than the currently used version.
 export const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
-  const { version, conditions } = await getCompatibleEntry({
-    versions,
-    nodeVersion,
-    packageJson,
-    buildDir,
-    pinnedVersion,
-  })
-  const compatWarning = getCompatWarning(conditions)
-  return { version, compatWarning }
-}
-
+    const { version, conditions } = await getCompatibleEntry({
+        versions,
+        nodeVersion,
+        packageJson,
+        buildDir,
+        pinnedVersion,
+    });
+    const compatWarning = getCompatWarning(conditions);
+    return { version, compatWarning };
+};
 // This function finds the right `compatibility` entry to use with the plugin.
 //  - `compatibitlity` entries are meant for backward compatibility
 //    Plugins should define each major version in `compatibility`.
@@ -41,92 +38,67 @@ export const getExpectedVersion = async function ({ versions, nodeVersion, packa
 //  - If there is a `pinnedVersion`, use it unless `latestVersion` matches it
 //  - Otherwise, use `latestVersion`
 const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
-  if (pinnedVersion !== undefined) {
-    const matchingVersion = versions.find(({ version }) =>
-      semver.satisfies(version, pinnedVersion, { includePrerelease: true }),
-    )
-
-    return matchingVersion || { version: pinnedVersion }
-  }
-
-  const versionsWithConditions = versions.filter(hasConditions)
-  const compatibleEntry = await pLocate(versionsWithConditions, ({ conditions }) =>
-    matchesCompatField({ conditions, nodeVersion, packageJson, buildDir }),
-  )
-  return compatibleEntry || { version: versions[0].version }
-}
-
+    if (pinnedVersion !== undefined) {
+        const matchingVersion = versions.find(({ version }) => semver.satisfies(version, pinnedVersion, { includePrerelease: true }));
+        return matchingVersion || { version: pinnedVersion };
+    }
+    const versionsWithConditions = versions.filter(hasConditions);
+    const compatibleEntry = await pLocate(versionsWithConditions, ({ conditions }) => matchesCompatField({ conditions, nodeVersion, packageJson, buildDir }));
+    return compatibleEntry || { version: versions[0].version };
+};
 // Ignore entries without conditions. Those are used to specify breaking
 // changes, i.e. meant to be used for version pinning instead.
 const hasConditions = function ({ conditions }) {
-  return conditions.length !== 0
-}
-
+    return conditions.length !== 0;
+};
 const matchesCompatField = async function ({ conditions, nodeVersion, packageJson, buildDir }) {
-  return await pEvery(conditions, ({ type, condition }) =>
-    CONDITIONS[type].test(condition, { nodeVersion, packageJson, buildDir }),
-  )
-}
-
+    return await pEvery(conditions, ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, buildDir }));
+};
 // Retrieve warning message shown when using an older version with `compatibility`
 const getCompatWarning = function (conditions = []) {
-  return conditions.map(getConditionWarning).join(', ')
-}
-
+    return conditions.map(getConditionWarning).join(', ');
+};
 const getConditionWarning = function ({ type, condition }) {
-  return CONDITIONS[type].warning(condition)
-}
-
+    return CONDITIONS[type].warning(condition);
+};
 // Plugins can use `compatibility.{version}.nodeVersion: 'allowedNodeVersion'`
 // to deliver different plugin versions based on the Node.js version
 const nodeVersionTest = function (allowedNodeVersion, { nodeVersion }) {
-  return semver.satisfies(nodeVersion, allowedNodeVersion)
-}
-
+    return semver.satisfies(nodeVersion, allowedNodeVersion);
+};
 const nodeVersionWarning = function (allowedNodeVersion) {
-  return `Node.js ${allowedNodeVersion}`
-}
-
-const siteDependenciesTest = async function (
-  allowedSiteDependencies,
-  { packageJson: { devDependencies, dependencies }, buildDir },
-) {
-  const siteDependencies = { ...devDependencies, ...dependencies }
-  return await pEvery(Object.entries(allowedSiteDependencies), ([dependencyName, allowedVersion]) =>
-    siteDependencyTest({ dependencyName, allowedVersion, siteDependencies, buildDir }),
-  )
-}
-
+    return `Node.js ${allowedNodeVersion}`;
+};
+const siteDependenciesTest = async function (allowedSiteDependencies, { packageJson: { devDependencies, dependencies }, buildDir }) {
+    const siteDependencies = { ...devDependencies, ...dependencies };
+    return await pEvery(Object.entries(allowedSiteDependencies), ([dependencyName, allowedVersion]) => siteDependencyTest({ dependencyName, allowedVersion, siteDependencies, buildDir }));
+};
 const siteDependencyTest = async function ({ dependencyName, allowedVersion, siteDependencies, buildDir }) {
-  const siteDependency = siteDependencies[dependencyName]
-  if (typeof siteDependency !== 'string') {
-    return false
-  }
-
-  // if this is a valid version we can apply the rule directly
-  if (semver.clean(siteDependency) !== null) {
-    return semver.satisfies(siteDependency, allowedVersion)
-  }
-
-  try {
-    // if this is a range we need to get the exact version
-    const packageJsonPath = await resolvePath(`${dependencyName}/package.json`, buildDir)
-    const { version } = await importJsonFile(packageJsonPath)
-    return semver.satisfies(version, allowedVersion)
-  } catch {
-    return false
-  }
-}
-
+    const siteDependency = siteDependencies[dependencyName];
+    if (typeof siteDependency !== 'string') {
+        return false;
+    }
+    // if this is a valid version we can apply the rule directly
+    if (semver.clean(siteDependency) !== null) {
+        return semver.satisfies(siteDependency, allowedVersion);
+    }
+    try {
+        // if this is a range we need to get the exact version
+        const packageJsonPath = await resolvePath(`${dependencyName}/package.json`, buildDir);
+        const { version } = await importJsonFile(packageJsonPath);
+        return semver.satisfies(version, allowedVersion);
+    }
+    catch {
+        return false;
+    }
+};
 const siteDependenciesWarning = function (allowedSiteDependencies) {
-  return Object.entries(allowedSiteDependencies).map(siteDependencyWarning).join(',')
-}
-
+    return Object.entries(allowedSiteDependencies).map(siteDependencyWarning).join(',');
+};
 const siteDependencyWarning = function ([dependencyName, allowedVersion]) {
-  return `${dependencyName}@${allowedVersion}`
-}
-
+    return `${dependencyName}@${allowedVersion}`;
+};
 export const CONDITIONS = {
-  nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
-  siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
-}
+    nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
+    siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
+};

package/lib/plugins/error.js

@@ -1,52 +1,46 @@
-import { addErrorInfo } from '../error/info.js'
-import { logFailPluginWarning } from '../log/messages/plugins.js'
-
+import { addErrorInfo } from '../error/info.js';
+import { logFailPluginWarning } from '../log/messages/plugins.js';
 // Stop build.
 // As opposed to throwing an error directly or to uncaught exceptions, this is
 // displayed as a user error, not an implementation error.
 export const failBuild = function (message, opts) {
-  throw normalizeError('failBuild', failBuild, message, opts)
-}
-
+    throw normalizeError('failBuild', failBuild, message, opts);
+};
 // Stop plugin. Same as `failBuild` but only stops plugin not whole build
 export const failPlugin = function (message, opts) {
-  throw normalizeError('failPlugin', failPlugin, message, opts)
-}
-
+    throw normalizeError('failPlugin', failPlugin, message, opts);
+};
 // Cancel build. Same as `failBuild` except it marks the build as "canceled".
 export const cancelBuild = function (message, opts) {
-  throw normalizeError('cancelBuild', cancelBuild, message, opts)
-}
-
+    throw normalizeError('cancelBuild', cancelBuild, message, opts);
+};
 // `onSuccess`, `onEnd` and `onError` cannot cancel the build since they are run
 // or might be run after deployment. When calling `failBuild()` or
 // `cancelBuild()`, `failPlugin()` is run instead and a warning is printed.
 export const failPluginWithWarning = function (methodName, event, message, opts) {
-  logFailPluginWarning(methodName, event)
-  failPlugin(message, opts)
-}
-
+    logFailPluginWarning(methodName, event);
+    failPlugin(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, errorMetadata } = {}) {
-  const errorA = getError(error, message, func)
-  addErrorInfo(errorA, { type, errorMetadata })
-  return errorA
-}
-
+    const errorA = getError(error, message, func);
+    addErrorInfo(errorA, { type, errorMetadata });
+    return errorA;
+};
 const getError = function (error, message, func) {
-  if (error instanceof Error) {
-    // This might fail if `name` is a getter or is non-writable.
-    try {
-      error.message = `${message}\n${error.message}`
-    } catch {
-      // continue regardless error
+    if (error instanceof Error) {
+        // This might fail if `name` is a getter or is non-writable.
+        try {
+            error.message = `${message}\n${error.message}`;
+        }
+        catch {
+            // continue regardless error
+        }
+        return error;
     }
-    return error
-  }
-
-  const errorA = new Error(message)
-  // Do not include function itself in the stack trace
-  Error.captureStackTrace(errorA, func)
-  return errorA
-}
+    const errorA = new Error(message);
+    // Do not include function itself in the stack trace
+    Error.captureStackTrace(errorA, func);
+    return errorA;
+};

package/lib/plugins/events.js

@@ -1,17 +1,12 @@
-export { DEV_EVENTS, EVENTS } from '@netlify/config'
-
+export { DEV_EVENTS, EVENTS } from '@netlify/config';
 const isAmongEvents = function (events, event) {
-  return events.includes(event)
-}
-
+    return events.includes(event);
+};
 // Check if failure of the event should not make the build fail
-export const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd'])
-
+export const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd']);
 // Check if the event is triggered even when the build fails
-export const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd'])
-
+export const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd']);
 // Check if the event is only triggered when the build fails
-export const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError'])
-
+export const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError']);
 // Check if the event is happening after deploy
-export const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd'])
+export const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd']);

package/lib/plugins/expected_version.js

@@ -1,119 +1,81 @@
-import semver from 'semver'
-
-import { addErrorInfo } from '../error/info.js'
-import { importJsonFile } from '../utils/json.js'
-import { resolvePath } from '../utils/resolve.js'
-
-import { getExpectedVersion } from './compatibility.js'
-import { getPluginsList } from './list.js'
-
+import semver from 'semver';
+import { addErrorInfo } from '../error/info.js';
+import { importJsonFile } from '../utils/json.js';
+import { resolvePath } from '../utils/resolve.js';
+import { getExpectedVersion } from './compatibility.js';
+import { getPluginsList } from './list.js';
 // When using plugins in our official list, those are installed in .netlify/plugins/
 // We ensure that the last version that's been approved is always the one being used.
 // We also ensure that the plugin is our official list.
-export const addExpectedVersions = async function ({
-  pluginsOptions,
-  autoPluginsDir,
-  packageJson,
-  debug,
-  logs,
-  buildDir,
-  testOpts,
-  featureFlags,
-}) {
-  if (!pluginsOptions.some(needsExpectedVersion)) {
-    return pluginsOptions
-  }
-
-  const pluginsList = await getPluginsList({ debug, logs, testOpts })
-  return await Promise.all(
-    pluginsOptions.map((pluginOptions) =>
-      addExpectedVersion({ pluginsList, autoPluginsDir, packageJson, pluginOptions, buildDir, featureFlags }),
-    ),
-  )
-}
-
+export const addExpectedVersions = async function ({ pluginsOptions, autoPluginsDir, packageJson, debug, logs, buildDir, testOpts, featureFlags, }) {
+    if (!pluginsOptions.some(needsExpectedVersion)) {
+        return pluginsOptions;
+    }
+    const pluginsList = await getPluginsList({ debug, logs, testOpts });
+    return await Promise.all(pluginsOptions.map((pluginOptions) => addExpectedVersion({ pluginsList, autoPluginsDir, packageJson, pluginOptions, buildDir, featureFlags })));
+};
 // Any `pluginOptions` with `expectedVersion` set will be automatically installed
-const addExpectedVersion = async function ({
-  pluginsList,
-  autoPluginsDir,
-  packageJson,
-  pluginOptions,
-  pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion },
-  buildDir,
-  featureFlags,
-}) {
-  if (!needsExpectedVersion(pluginOptions)) {
-    return pluginOptions
-  }
-
-  if (pluginsList[packageName] === undefined) {
-    validateUnlistedPlugin(packageName, loadedFrom)
-    return pluginOptions
-  }
-
-  const unfilteredVersions = pluginsList[packageName]
-  const versions = filterVersions(unfilteredVersions, featureFlags)
-  const [{ version: latestVersion, migrationGuide }] = versions
-  const [{ version: expectedVersion }, { version: compatibleVersion, compatWarning }] = await Promise.all([
-    getExpectedVersion({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }),
-    getExpectedVersion({ versions, nodeVersion, packageJson, buildDir }),
-  ])
-
-  const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion })
-  return {
-    ...pluginOptions,
-    latestVersion,
-    expectedVersion,
-    compatibleVersion,
-    migrationGuide,
-    compatWarning,
-    isMissing,
-  }
-}
-
+const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packageJson, pluginOptions, pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion }, buildDir, featureFlags, }) {
+    if (!needsExpectedVersion(pluginOptions)) {
+        return pluginOptions;
+    }
+    if (pluginsList[packageName] === undefined) {
+        validateUnlistedPlugin(packageName, loadedFrom);
+        return pluginOptions;
+    }
+    const unfilteredVersions = pluginsList[packageName];
+    const versions = filterVersions(unfilteredVersions, featureFlags);
+    const [{ version: latestVersion, migrationGuide }] = versions;
+    const [{ version: expectedVersion }, { version: compatibleVersion, compatWarning }] = await Promise.all([
+        getExpectedVersion({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }),
+        getExpectedVersion({ versions, nodeVersion, packageJson, buildDir }),
+    ]);
+    const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion });
+    return {
+        ...pluginOptions,
+        latestVersion,
+        expectedVersion,
+        compatibleVersion,
+        migrationGuide,
+        compatWarning,
+        isMissing,
+    };
+};
 // Feature flagged versions are removed unless the feature flag is present.
 //  - This is done before conditions are applied since, unlike conditions,
 //    users cannot always choose to enable a feature flag.
 const filterVersions = function (unfilteredVersions, featureFlags) {
-  return unfilteredVersions.filter(({ featureFlag }) => featureFlag === undefined || featureFlags[featureFlag])
-}
-
+    return unfilteredVersions.filter(({ featureFlag }) => featureFlag === undefined || featureFlags[featureFlag]);
+};
 // Checks whether plugin should be installed due to the wrong version being used
 // (either outdated, or mismatching compatibility requirements)
 const isMissingVersion = async function ({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion }) {
-  return (
+    return (
     // We always respect the versions specified in `package.json`, as opposed
     // to auto-installed plugins
     loadedFrom !== 'package.json' &&
-    // Plugin was not previously installed
-    (pluginPath === undefined ||
-      // Plugin was previously installed but a different version should be used
-      !semver.satisfies(await getAutoPluginVersion(packageName, autoPluginsDir), expectedVersion))
-  )
-}
-
+        // Plugin was not previously installed
+        (pluginPath === undefined ||
+            // Plugin was previously installed but a different version should be used
+            !semver.satisfies(await getAutoPluginVersion(packageName, autoPluginsDir), expectedVersion)));
+};
 const getAutoPluginVersion = async function (packageName, autoPluginsDir) {
-  const packageJsonPath = await resolvePath(`${packageName}/package.json`, autoPluginsDir)
-  const { version } = await importJsonFile(packageJsonPath)
-  return version
-}
-
+    const packageJsonPath = await resolvePath(`${packageName}/package.json`, autoPluginsDir);
+    const { version } = await importJsonFile(packageJsonPath);
+    return version;
+};
 const needsExpectedVersion = function ({ loadedFrom }) {
-  return loadedFrom === 'auto_install' || loadedFrom === 'package.json'
-}
-
+    return loadedFrom === 'auto_install' || loadedFrom === 'package.json';
+};
 // Plugins that are not in our official list can only be specified in
 // `netlify.toml` providing they are also installed in the site's package.json.
 // Otherwise, the build should fail.
 const validateUnlistedPlugin = function (packageName, loadedFrom) {
-  if (loadedFrom === 'package.json') {
-    return
-  }
-
-  const error = new Error(
-    `Plugins must be installed either in the Netlify App or in "package.json".
-Please run "npm install -D ${packageName}" or "yarn add -D ${packageName}".`,
-  )
-  addErrorInfo(error, { type: 'resolveConfig' })
-  throw error
-}
+    if (loadedFrom === 'package.json') {
+        return;
+    }
+    const error = new Error(`Plugins must be installed either in the Netlify App or in "package.json".
+Please run "npm install -D ${packageName}" or "yarn add -D ${packageName}".`);
+    addErrorInfo(error, { type: 'resolveConfig' });
+    throw error;
+};