@netlify/build 29.31.5 → 29.32.1

package/lib/log/messages/plugins.d.ts

@@ -1,8 +1,10 @@
-export function logPluginsFetchError(logs: any, message: any): void;
-export function logPluginsList({ pluginsList, debug, logs }: {
-    pluginsList: any;
-    debug: any;
-    logs: any;
-}): void;
-export function logFailPluginWarning(methodName: any, event: any): void;
-export function logDeploySuccess(logs: any): void;
+import type { PluginList } from '../../plugins/list.js';
+import { BufferedLogs } from '../logger.js';
+export declare const logPluginsFetchError: (logs: BufferedLogs | undefined, message: string) => void;
+export declare const logPluginsList: ({ pluginsList, debug, logs, }: {
+    pluginsList: PluginList;
+    logs: BufferedLogs | undefined;
+    debug?: boolean | undefined;
+}) => void;
+export declare const logFailPluginWarning: (methodName: any, event: any) => void;
+export declare const logDeploySuccess: (logs?: BufferedLogs) => void;

package/lib/log/messages/plugins.js

@@ -1,20 +1,19 @@
-import { log, logArray, logWarning, logSubHeader } from '../logger.js';
+import { log, logArray, logSubHeader, logWarning } from '../logger.js';
 export const logPluginsFetchError = function (logs, message) {
     logWarning(logs, `
 Warning: could not fetch latest plugins list. Plugins versions might not be the latest.
 ${message}`);
 };
-export const logPluginsList = function ({ pluginsList, debug, logs }) {
+export const logPluginsList = function ({ pluginsList, debug, logs, }) {
     if (!debug) {
         return;
     }
-    const pluginsListArray = Object.entries(pluginsList).map(getPluginsListItem).sort();
+    const pluginsListArray = Object.entries(pluginsList)
+        .map(([packageName, versions]) => `${packageName}@${versions[0].version}`)
+        .sort();
     logSubHeader(logs, 'Available plugins');
     logArray(logs, pluginsListArray);
 };
-const getPluginsListItem = function ([packageName, versions]) {
-    return `${packageName}@${versions[0].version}`;
-};
 export const logFailPluginWarning = function (methodName, event) {
     logWarning(undefined, `Plugin error: since "${event}" happens after deploy, the build has already succeeded and cannot fail anymore. This plugin should either:
 - use utils.build.failPlugin() instead of utils.build.${methodName}() to clarify that the plugin failed, but not the build.

package/lib/plugins/compatibility.d.ts

@@ -1,33 +1,25 @@
-export function getExpectedVersion({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }: {
-    versions: any;
-    nodeVersion: any;
-    packageJson: any;
-    buildDir: any;
-    pinnedVersion: any;
-}): Promise<{
-    version: any;
+import { PackageJson } from 'read-pkg-up';
+import { PluginVersion } from './list.js';
+/**
+ *  Retrieve the `expectedVersion` of a plugin:
+ *   - This is the version which should be run
+ *   - This takes version pinning into account
+ *   - If this does not match the currently cached version, it is installed first
+ *  This is also used to retrieve the `compatibleVersion` of a plugin
+ *   - This is the most recent version compatible with this site
+ *   - This is the same logic except it does not use version pinning
+ *   - This is only used to print a warning message when the `compatibleVersion`
+ *     is older than the currently used version.
+ */
+export declare const getExpectedVersion: ({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion, }: {
+    versions: PluginVersion[];
+    /** The package.json of the repository */
+    packageJson: PackageJson;
+    packagePath?: string | undefined;
+    buildDir: string;
+    nodeVersion: string;
+    pinnedVersion?: string | undefined;
+}) => Promise<{
+    version: string;
     compatWarning: string;
 }>;
-export namespace CONDITIONS {
-    namespace nodeVersion {
-        export { nodeVersionTest as test };
-        export { nodeVersionWarning as warning };
-    }
-    namespace siteDependencies {
-        export { siteDependenciesTest as test };
-        export { siteDependenciesWarning as warning };
-    }
-}
-declare function nodeVersionTest(allowedNodeVersion: any, { nodeVersion }: {
-    nodeVersion: any;
-}): boolean;
-declare function nodeVersionWarning(allowedNodeVersion: any): string;
-declare function siteDependenciesTest(allowedSiteDependencies: any, { packageJson: { devDependencies, dependencies }, buildDir }: {
-    packageJson: {
-        devDependencies: any;
-        dependencies: any;
-    };
-    buildDir: any;
-}): Promise<any>;
-declare function siteDependenciesWarning(allowedSiteDependencies: any): string;
-export {};

package/lib/plugins/compatibility.js

@@ -1,104 +1,63 @@
-import pEvery from 'p-every';
+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
-//  - If this does not match the currently cached version, it is installed first
-// This is also used to retrieve the `compatibleVersion` of a plugin
-//  - This is the most recent version compatible with this site
-//  - This is the same logic except it does not use version pinning
-//  - 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({
+import { CONDITIONS } from './plugin_conditions.js';
+// the types of that package seem to be not correct and demand a `pEvery.default()` usage which is wrong
+const pEvery = _pEvery;
+/**
+ *  Retrieve the `expectedVersion` of a plugin:
+ *   - This is the version which should be run
+ *   - This takes version pinning into account
+ *   - If this does not match the currently cached version, it is installed first
+ *  This is also used to retrieve the `compatibleVersion` of a plugin
+ *   - This is the most recent version compatible with this site
+ *   - This is the same logic except it does not use version pinning
+ *   - 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, packagePath, buildDir, pinnedVersion, }) {
+    const { version, conditions = [] } = await getCompatibleEntry({
         versions,
         nodeVersion,
         packageJson,
+        packagePath,
         buildDir,
         pinnedVersion,
     });
-    const compatWarning = getCompatWarning(conditions);
+    // Retrieve warning message shown when using an older version with `compatibility`
+    const compatWarning = conditions.map(({ type, condition }) => CONDITIONS[type].warning(condition)).join(', ');
     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`.
-//  - The entries are sorted from most to least recent version.
-//  - After their first successful run, plugins are pinned by their major
-//    version which is passed as `pinnedVersion` to the next builds.
-// When the plugin does not have a `pinnedVersion`, we use the most recent
-// `compatibility` entry with a successful condition.
-// When the plugin has a `pinnedVersion`, we do not use the `compatibility`
-// conditions. Instead, we just use the most recent entry with a `version`
-// matching `pinnedVersion`.
-// When no `compatibility` entry matches, we use:
-//  - 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 };
-};
-// 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;
-};
-const matchesCompatField = async function ({ conditions, 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(', ');
-};
-const getConditionWarning = function ({ type, 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);
-};
-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 }));
-};
-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 siteDependenciesWarning = function (allowedSiteDependencies) {
-    return Object.entries(allowedSiteDependencies).map(siteDependencyWarning).join(',');
-};
-const siteDependencyWarning = function ([dependencyName, allowedVersion]) {
-    return `${dependencyName}@${allowedVersion}`;
-};
-export const CONDITIONS = {
-    nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
-    siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
+/**
+ *  This function finds the right `compatibility` entry to use with the plugin.
+ *   - `compatibility` entries are meant for backward compatibility
+ *     Plugins should define each major version in `compatibility`.
+ *   - The entries are sorted from most to least recent version.
+ *   - After their first successful run, plugins are pinned by their major
+ *     version which is passed as `pinnedVersion` to the next builds.
+ *  When the plugin does not have a `pinnedVersion`, we use the most recent
+ *  `compatibility` entry with a successful condition.
+ *  When the plugin has a `pinnedVersion`, we do not use the `compatibility`
+ *  conditions. Instead, we just use the most recent entry with a `version`
+ *  matching `pinnedVersion`.
+ *  When no `compatibility` entry matches, we use:
+ *   - If there is a `pinnedVersion`, use it unless `latestVersion` matches it
+ *   - Otherwise, use `latestVersion`
+ */
+const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion, }) {
+    const compatibleEntry = await pLocate(versions, async ({ version, overridePinnedVersion, conditions }) => {
+        // Detect if the overridePinnedVersion intersects with the pinned version in this case we don't care about filtering
+        const overridesPin = Boolean(pinnedVersion && overridePinnedVersion && semver.intersects(overridePinnedVersion, pinnedVersion));
+        // ignore versions that don't satisfy the pinned version here if a pinned version is set
+        if (!overridesPin && pinnedVersion && !semver.satisfies(version, pinnedVersion, { includePrerelease: true })) {
+            return false;
+        }
+        // no conditions means nothing to filter
+        if (conditions.length === 0 && pinnedVersion === undefined) {
+            return false;
+        }
+        return await pEvery(conditions, async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir }));
+    });
+    return (compatibleEntry ||
+        (pinnedVersion ? { version: pinnedVersion, conditions: [] } : { version: versions[0].version, conditions: [] }));
 };

package/lib/plugins/compatibility.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/plugins/compatibility.test.js

@@ -0,0 +1,148 @@
+import { expect, test } from 'vitest';
+import { getExpectedVersion } from './compatibility.js';
+test('`getExpectedVersion` should ignore the new major version if the version is pinned', async () => {
+    const versions = [
+        { version: '5.0.0', conditions: [] },
+        { version: '4.41.2', conditions: [] },
+    ];
+    const { version } = await getExpectedVersion({
+        versions,
+        nodeVersion: '18.19.0',
+        packageJson: {},
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version).toBe('4.41.2');
+});
+test('`getExpectedVersion` matches prerelease versions', async () => {
+    const versions = [
+        { version: '5.0.0', conditions: [] },
+        { version: '4.42.0-alpha.1', conditions: [] },
+        { version: '4.41.2', conditions: [] },
+    ];
+    const { version: version1 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '18.19.0',
+        packageJson: {},
+        buildDir: '/some/path',
+    });
+    const { version: version2 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '18.19.0',
+        packageJson: {},
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version1).toBe('5.0.0');
+    expect(version2).toBe('4.42.0-alpha.1');
+});
+test('`getExpectedVersion`should retrieve a new major version if the overridePinnedVersion is specified', async () => {
+    const versions = [
+        { version: '5.0.0', conditions: [], overridePinnedVersion: '>=4.0.0' },
+        { version: '4.41.2', conditions: [] },
+    ];
+    const { version } = await getExpectedVersion({
+        versions,
+        nodeVersion: '18.19.0',
+        packageJson: {},
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version).toBe('5.0.0');
+});
+test('`getExpectedVersion`should retrieve the plugin based on the condition of a nodeVersion', async () => {
+    const versions = [
+        {
+            version: '4.42.0',
+            conditions: [{ type: 'nodeVersion', condition: '>=18.0.0' }],
+        },
+        { version: '4.41.2', conditions: [] },
+    ];
+    const { version } = await getExpectedVersion({
+        versions,
+        nodeVersion: '17.19.0',
+        packageJson: {},
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version).toBe('4.41.2');
+});
+test('`getExpectedVersion` should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
+    const versions = [
+        {
+            version: '5.0.0-beta.1',
+            conditions: [
+                { type: 'nodeVersion', condition: '>= 18.0.0' },
+                { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+            ],
+            overridePinnedVersion: '>=4.0.0',
+        },
+        {
+            version: '4.42.0',
+            conditions: [{ type: 'siteDependencies', condition: { next: '>=10.0.9' } }],
+        },
+        { version: '4.41.2', conditions: [] },
+        {
+            version: '3.9.2',
+            conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+        },
+    ];
+    const { version: version1 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '17.19.0',
+        packageJson: { dependencies: { next: '10.0.8' } },
+        buildDir: '/some/path',
+        pinnedVersion: '3',
+    });
+    expect(version1).toBe('3.9.2');
+    const { version: version2 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '17.19.0',
+        packageJson: { dependencies: { next: '11.0.0' } },
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version2).toBe('4.42.0');
+    const { version: version3 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '18.19.0',
+        packageJson: { dependencies: { next: '13.5.0' } },
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version3).toBe('5.0.0-beta.1');
+});
+test('`getExpectedVersion` should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
+    const versions = [
+        {
+            version: '5.0.0-beta.1',
+            conditions: [
+                { type: 'nodeVersion', condition: '>= 18.0.0' },
+                { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+            ],
+            overridePinnedVersion: '>=4.0.0',
+        },
+        { version: '4.41.2', conditions: [] },
+        {
+            version: '3.9.2',
+            conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+        },
+    ];
+    const { version: version1 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '20.0.0',
+        packageJson: { dependencies: { next: '14.0.0' } },
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version1).toBe('5.0.0-beta.1');
+    // out of range
+    const { version: version2 } = await getExpectedVersion({
+        versions,
+        nodeVersion: '20.0.0',
+        packageJson: { dependencies: { next: '13.0.0' } },
+        buildDir: '/some/path',
+        pinnedVersion: '4',
+    });
+    expect(version2).toBe('4.41.2');
+});

package/lib/plugins/expected_version.d.ts

@@ -1,10 +1,11 @@
-export function addExpectedVersions({ pluginsOptions, autoPluginsDir, packageJson, debug, logs, buildDir, testOpts, featureFlags, }: {
+export declare const addExpectedVersions: ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, debug, logs, buildDir, testOpts, featureFlags, }: {
     pluginsOptions: any;
     autoPluginsDir: any;
     packageJson: any;
+    packagePath: any;
     debug: any;
     logs: any;
     buildDir: any;
     testOpts: any;
     featureFlags: any;
-}): Promise<any>;
+}) => Promise<any>;

package/lib/plugins/expected_version.js

@@ -7,15 +7,24 @@ 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, }) {
+export const addExpectedVersions = async function ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, 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, testOpts })));
+    return await Promise.all(pluginsOptions.map((pluginOptions) => addExpectedVersion({
+        pluginsList,
+        autoPluginsDir,
+        packageJson,
+        packagePath,
+        pluginOptions,
+        buildDir,
+        featureFlags,
+        testOpts,
+    })));
 };
-// 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, testOpts, }) {
+/** Any `pluginOptions` with `expectedVersion` set will be automatically installed */
+const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packageJson, packagePath, pluginOptions, pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion }, buildDir, featureFlags, testOpts, }) {
     if (!needsExpectedVersion(pluginOptions)) {
         return pluginOptions;
     }
@@ -27,8 +36,8 @@ const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packag
     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 }),
+        getExpectedVersion({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion }),
+        getExpectedVersion({ versions, nodeVersion, packageJson, packagePath, buildDir }),
     ]);
     const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion });
     return {
@@ -47,8 +56,10 @@ const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packag
 const filterVersions = function (unfilteredVersions, featureFlags) {
     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)
+/**
+ * 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 (
     // We always respect the versions specified in `package.json`, as opposed
@@ -62,6 +73,10 @@ const isMissingVersion = async function ({ autoPluginsDir, packageName, pluginPa
 const getAutoPluginVersion = async function (packageName, autoPluginsDir) {
     const packageJsonPath = await resolvePath(`${packageName}/package.json`, autoPluginsDir);
     const { version } = await importJsonFile(packageJsonPath);
+    if (!version) {
+        // this should never happen
+        throw new Error('No version specified for the plugin!');
+    }
     return version;
 };
 const needsExpectedVersion = function ({ loadedFrom }) {

package/lib/plugins/list.d.ts

@@ -1,9 +1,32 @@
-export function getPluginsList({ debug, logs, testOpts: { pluginsListUrl } }: {
-    debug: any;
-    logs: any;
-    testOpts: {
-        pluginsListUrl: any;
-    };
-}): Promise<never[] | {
-    [k: string]: any;
-}>;
+import { BufferedLogs } from '../log/logger.js';
+import { CONDITIONS } from './plugin_conditions.js';
+/**
+ * The resolved and normalized Plugin list
+ */
+export type PluginList = Record<string, PluginVersion[]>;
+export type PluginVersion = {
+    version: string;
+    migrationGuide?: string;
+    featureFlag?: string;
+    overridePinnedVersion?: string;
+    conditions: {
+        type: keyof typeof CONDITIONS;
+        condition: string | Record<string, string>;
+    }[];
+};
+/**
+ * Retrieve the list of plugins officially vetted by us and displayed in our
+ * plugins directory UI.
+ * We fetch this list during each build (no caching) because we want new
+ * versions of plugins to be available instantly to all users. The time to
+ * make this request is somewhat ok (in the 100ms range).
+ * We only fetch this plugins list when needed, i.e. we defer it as much as
+ * possible.
+ */
+export declare const getPluginsList: ({ debug, logs, testOpts: { pluginsListUrl }, }: {
+    testOpts?: {
+        pluginsListUrl?: string | undefined;
+    } | undefined;
+    debug?: boolean | undefined;
+    logs?: BufferedLogs | undefined;
+}) => Promise<PluginList>;

package/lib/plugins/list.js

@@ -2,21 +2,23 @@ import { pluginsUrl, pluginsList as oldPluginsList } from '@netlify/plugins-list
 import got from 'got';
 import isPlainObj from 'is-plain-obj';
 import { logPluginsList, logPluginsFetchError } from '../log/messages/plugins.js';
-import { CONDITIONS } from './compatibility.js';
-// 1 minute HTTP request timeout
+import { CONDITIONS } from './plugin_conditions.js';
+/** 1 minute HTTP request timeout */
 const PLUGINS_LIST_TIMEOUT = 6e4;
-// Retrieve the list of plugins officially vetted by us and displayed in our
-// plugins directory UI.
-// We fetch this list during each build (no caching) because we want new
-// versions of plugins to be available instantly to all users. The time to
-// make this request is somewhat ok (in the 100ms range).
-// We only fetch this plugins list when needed, i.e. we defer it as much as
-// possible.
-export const getPluginsList = async function ({ debug, logs, testOpts: { pluginsListUrl } }) {
+/**
+ * Retrieve the list of plugins officially vetted by us and displayed in our
+ * plugins directory UI.
+ * We fetch this list during each build (no caching) because we want new
+ * versions of plugins to be available instantly to all users. The time to
+ * make this request is somewhat ok (in the 100ms range).
+ * We only fetch this plugins list when needed, i.e. we defer it as much as
+ * possible.
+ */
+export const getPluginsList = async function ({ debug, logs, testOpts: { pluginsListUrl } = {}, }) {
     // We try not to mock in integration tests. However, sending a request for
     // each test would be too slow and make tests unreliable.
     if (pluginsListUrl === 'test') {
-        return [];
+        return {};
     }
     const pluginsListUrlA = pluginsListUrl === undefined ? pluginsUrl : pluginsListUrl;
     const pluginsList = await fetchPluginsList({ logs, pluginsListUrl: pluginsListUrlA });
@@ -24,7 +26,7 @@ export const getPluginsList = async function ({ debug, logs, testOpts: { plugins
     logPluginsList({ pluginsList: pluginsListA, debug, logs });
     return pluginsListA;
 };
-const fetchPluginsList = async function ({ logs, pluginsListUrl }) {
+const fetchPluginsList = async function ({ logs, pluginsListUrl, }) {
     try {
         const { body } = await got(pluginsListUrl, { responseType: 'json', timeout: { request: PLUGINS_LIST_TIMEOUT } });
         if (!isValidPluginsList(body)) {
@@ -49,21 +51,23 @@ const isValidPluginsList = function (pluginsList) {
 const normalizePluginsList = function (pluginsList) {
     return Object.fromEntries(pluginsList.map(normalizePluginItem));
 };
-// `version` in `plugins.json` is the latest version.
-// A `compatibility` array of objects can be added to specify conditions to
-// apply different versions.
-// `netlify/plugins` ensures that `compatibility`:
-//  - Has the proper shape.
-//  - Is sorted from the highest to lowest version.
-//  - Does not include the latest `version`.
+/**
+ * `version` in `plugins.json` is the latest version.
+ * A `compatibility` array of objects can be added to specify conditions to
+ * apply different versions.
+ * `netlify/plugins` ensures that `compatibility`:
+ *  - Has the proper shape.
+ *  - Is sorted from the highest to lowest version.
+ *  - Does not include the latest `version`.
+ */
 const normalizePluginItem = function ({ package: packageName, version, compatibility = [] }) {
     const versions = compatibility.length === 0 ? [{ version }] : compatibility;
     const versionsA = versions.map(normalizeCompatVersion);
     return [packageName, versionsA];
 };
-const normalizeCompatVersion = function ({ version, migrationGuide, featureFlag, ...otherProperties }) {
+const normalizeCompatVersion = function ({ version, migrationGuide, featureFlag, overridePinnedVersion, ...otherProperties }) {
     const conditions = Object.entries(otherProperties).filter(isCondition).map(normalizeCondition);
-    return { version, migrationGuide, featureFlag, conditions };
+    return { version, migrationGuide, overridePinnedVersion, featureFlag, conditions };
 };
 const isCondition = function ([type]) {
     return type in CONDITIONS;

package/lib/plugins/plugin_conditions.d.ts

@@ -0,0 +1,24 @@
+import { PackageJson } from 'read-pkg-up';
+import { type PluginVersion } from './list.js';
+type ConditionContext = {
+    nodeVersion: string;
+    packageJson: PackageJson;
+    buildDir: string;
+    packagePath?: string;
+};
+type PluginCondition = PluginVersion['conditions'][number]['condition'];
+export type Condition = {
+    test: (condition: PluginCondition, ctx: ConditionContext) => boolean | Promise<boolean>;
+    warning: (condition: PluginCondition) => void;
+};
+export declare const CONDITIONS: {
+    nodeVersion: {
+        test: (allowedNodeVersion: string, { nodeVersion }: ConditionContext) => boolean;
+        warning: (allowedNodeVersion: string) => string;
+    };
+    siteDependencies: {
+        test: (allowedSiteDependencies: Record<string, string>, { packageJson: { devDependencies, dependencies }, packagePath, buildDir }: ConditionContext) => Promise<boolean>;
+        warning: (allowedSiteDependencies: any) => string;
+    };
+};
+export {};

package/lib/plugins/plugin_conditions.js

@@ -0,0 +1,61 @@
+import { join } from 'path';
+import _pEvery from 'p-every';
+import semver from 'semver';
+import { importJsonFile } from '../utils/json.js';
+import { resolvePath } from '../utils/resolve.js';
+// the types of that package seem to be not correct and demand a `pEvery.default()` usage which is wrong
+const pEvery = _pEvery;
+/**
+ * Plugins can use `compatibility.{version}.nodeVersion: 'allowedNodeVersion'`
+ * to deliver different plugin versions based on the Node.js version
+ */
+const nodeVersionTest = (allowedNodeVersion, { nodeVersion }) => semver.satisfies(nodeVersion, allowedNodeVersion);
+const nodeVersionWarning = (allowedNodeVersion) => `Node.js ${allowedNodeVersion}`;
+const siteDependenciesTest = async function (allowedSiteDependencies, { packageJson: { devDependencies = {}, dependencies = {} }, packagePath, buildDir }) {
+    let siteDependencies = { ...devDependencies, ...dependencies };
+    // If there is a packagePath in a mono repository add the dependencies from the package as well
+    // the packageJson is in this case only the top root package json which does not contain all the dependencies to test for
+    const pkgJsonPath = packagePath && join(buildDir, packagePath, 'package.json');
+    if (pkgJsonPath) {
+        try {
+            const { devDependencies: devDepsPgk = {}, dependencies: depsPkg = {} } = await importJsonFile(pkgJsonPath);
+            siteDependencies = { ...siteDependencies, ...devDepsPgk, ...depsPkg };
+        }
+        catch {
+            // noop
+        }
+    }
+    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);
+        if (!version) {
+            return false;
+        }
+        return semver.satisfies(version, allowedVersion);
+    }
+    catch {
+        return false;
+    }
+};
+const siteDependenciesWarning = function (allowedSiteDependencies) {
+    return Object.entries(allowedSiteDependencies).map(siteDependencyWarning).join(',');
+};
+const siteDependencyWarning = function ([dependencyName, allowedVersion]) {
+    return `${dependencyName}@${allowedVersion}`;
+};
+export const CONDITIONS = {
+    nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
+    siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
+};

package/lib/plugins/resolve.js

@@ -26,6 +26,7 @@ export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, bu
         pluginsOptions: pluginsOptionsC,
         autoPluginsDir,
         packageJson,
+        packagePath,
         debug,
         logs,
         buildDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.31.5",
+  "version": "29.32.1",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -26,9 +26,12 @@
     "postbuild": "npx copyfiles \"src/**/*.yml\" lib/ -u 1",
     "build": "tsc",
     "test:types": "tsd",
-    "test": "ava && tsd",
+    "test": "ava && tsd && vitest run",
     "test:dev": "ava -w",
-    "test:ci": "c8 -r lcovonly -r text -r json ava && tsd",
+    "test:ci": "run-p test:ci:*",
+    "test:ci:types": "tsd",
+    "test:ci:ava": "c8 -r lcovonly -r text -r json ava",
+    "test:ci:vitest": "vitest run",
     "test:measure": "../../tools/tests-duration.js"
   },
   "keywords": [
@@ -65,10 +68,10 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/blobs": "^6.3.1",
+    "@netlify/blobs": "^6.4.2",
     "@netlify/cache-utils": "^5.1.5",
-    "@netlify/config": "^20.10.1",
-    "@netlify/edge-bundler": "10.1.3",
+    "@netlify/config": "^20.10.2",
+    "@netlify/edge-bundler": "11.2.0",
     "@netlify/framework-info": "^9.8.10",
     "@netlify/functions-utils": "^5.2.46",
     "@netlify/git-utils": "^5.1.1",
@@ -127,6 +130,7 @@
     "@netlify/nock-udp": "^3.1.2",
     "@opentelemetry/sdk-trace-base": "^1.18.1",
     "@types/node": "^14.18.53",
+    "@vitest/coverage-c8": "^0.30.1",
     "atob": "^2.1.2",
     "ava": "^4.0.0",
     "c8": "^7.12.0",
@@ -139,11 +143,13 @@
     "get-stream": "^6.0.0",
     "has-ansi": "^5.0.0",
     "moize": "^6.0.0",
+    "npm-run-all": "^4.1.5",
     "path-key": "^4.0.0",
     "process-exists": "^5.0.0",
     "sinon": "^13.0.0",
     "tmp-promise": "^3.0.2",
     "tsd": "^0.29.0",
+    "vitest": "^0.30.1",
     "yarn": "^1.22.4"
   },
   "peerDependencies": {
@@ -157,5 +163,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "f8462d09c2cba21e9ffa52296ccc42f50a3c2495"
+  "gitHead": "be80dc14bac4c67333c36dfe5a056bbf50ac4288"
 }