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

package/lib/plugins/child/utils.js

@@ -0,0 +1,42 @@
+import { bindOpts as cacheBindOpts } from '@netlify/cache-utils';
+import { add as functionsAdd, list as functionsList, listAll as functionsListAll } from '@netlify/functions-utils';
+import { getGitUtils } from '@netlify/git-utils';
+import { run, runCommand } from '@netlify/run-utils';
+import { failBuild, failPlugin, cancelBuild, failPluginWithWarning } from '../error.js';
+import { isSoftFailEvent } from '../events.js';
+import { addLazyProp } from './lazy.js';
+import { show } from './status.js';
+// Retrieve the `utils` argument.
+export const getUtils = function ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, runState, }) {
+    run.command = runCommand;
+    const build = getBuildUtils(event);
+    const cache = getCacheUtils(CACHE_DIR);
+    const functions = getFunctionsUtils(FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC);
+    const status = getStatusUtils(runState);
+    const utils = { build, cache, run, functions, status };
+    addLazyProp(utils, 'git', () => getGitUtils());
+    return utils;
+};
+const getBuildUtils = function (event) {
+    if (isSoftFailEvent(event)) {
+        return {
+            failPlugin,
+            failBuild: failPluginWithWarning.bind(null, 'failBuild', event),
+            cancelBuild: failPluginWithWarning.bind(null, 'cancelBuild', event),
+        };
+    }
+    return { failBuild, failPlugin, cancelBuild };
+};
+const getCacheUtils = function (CACHE_DIR) {
+    return cacheBindOpts({ cacheDir: CACHE_DIR });
+};
+const getFunctionsUtils = function (FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC) {
+    const functionsDirectories = [INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC].filter(Boolean);
+    const add = (src) => functionsAdd(src, INTERNAL_FUNCTIONS_SRC, { fail: failBuild });
+    const list = functionsList.bind(null, functionsDirectories, { fail: failBuild });
+    const listAll = functionsListAll.bind(null, functionsDirectories, { fail: failBuild });
+    return { add, list, listAll };
+};
+const getStatusUtils = function (runState) {
+    return { show: show.bind(undefined, runState) };
+};

package/lib/plugins/child/validate.js

@@ -0,0 +1,31 @@
+import { addErrorInfo } from '../../error/info.js';
+import { serializeArray } from '../../log/serialize.js';
+import { DEV_EVENTS, EVENTS } from '../events.js';
+// Validate the shape of a plugin return value
+export const validatePlugin = function (logic) {
+    try {
+        // This validation must work with the return value of `import()` which has
+        // a `Module` prototype, not `Object`
+        if (typeof logic !== 'object' || logic === null) {
+            throw new Error('Plugin must be an object or a function');
+        }
+        Object.entries(logic).forEach(([propName, value]) => {
+            validateEventHandler(value, propName);
+        });
+    }
+    catch (error) {
+        addErrorInfo(error, { type: 'pluginValidation' });
+        throw error;
+    }
+};
+// All other properties are event handlers
+const validateEventHandler = function (value, propName) {
+    if (!EVENTS.includes(propName) && !DEV_EVENTS.includes(propName)) {
+        throw new Error(`Invalid event '${propName}'.
+Please use a valid event name. One of:
+${serializeArray(EVENTS)}`);
+    }
+    if (typeof value !== 'function') {
+        throw new TypeError(`Invalid event handler '${propName}': must be a function`);
+    }
+};

package/lib/plugins/compatibility.js

@@ -0,0 +1,104 @@
+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({
+        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`.
+//  - 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 },
+};

package/{src → lib}/plugins/error.js

@@ -1,50 +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 } = {}) {
-  const errorA = getError(error, message, func)
-  addErrorInfo(errorA, { type })
-  return errorA
-}
-
+const normalizeError = function (type, func, message, { error, errorMetadata } = {}) {
+    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 {}
-    return error
-  }
-
-  const errorA = new Error(message)
-  // Do not include function itself in the stack trace
-  Error.captureStackTrace(errorA, func)
-  return errorA
-}
+    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;
+    }
+    const errorA = new Error(message);
+    // Do not include function itself in the stack trace
+    Error.captureStackTrace(errorA, func);
+    return errorA;
+};

package/{src → lib}/plugins/events.js

@@ -1,17 +1,12 @@
-export { 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

@@ -0,0 +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';
+// 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 })));
+};
+// 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,
+    };
+};
+// 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]);
+};
+// 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
+    // 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)));
+};
+const getAutoPluginVersion = async function (packageName, autoPluginsDir) {
+    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';
+};
+// 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;
+};

package/lib/plugins/ipc.js

@@ -0,0 +1,120 @@
+import process from 'process';
+import { promisify } from 'util';
+import { pEvent } from 'p-event';
+import { v4 as uuidv4 } from 'uuid';
+import { jsonToError, errorToJson } from '../error/build.js';
+import { addErrorInfo } from '../error/info.js';
+import { logSendingEventToChild, logSentEventToChild, logReceivedEventFromChild, logSendingEventToParent, } from '../log/messages/ipc.js';
+// Send event from child to parent process then wait for response
+// We need to fire them in parallel because `process.send()` can be slow
+// to await, i.e. child might send response before parent start listening for it
+export const callChild = async function ({ childProcess, eventName, payload, logs, verbose }) {
+    const callId = uuidv4();
+    const [response] = await Promise.all([
+        getEventFromChild(childProcess, callId),
+        sendEventToChild({ childProcess, callId, eventName, payload, logs, verbose }),
+    ]);
+    logReceivedEventFromChild(logs, verbose);
+    return response;
+};
+// Receive event from child to parent process
+// Wait for either:
+//  - `message` event with a specific `callId`
+//  - `message` event with an `error` `callId` indicating an exception in the
+//    child process
+//  - child process `exit`
+// In the later two cases, we propagate the error.
+// We need to make `p-event` listeners are properly cleaned up too.
+export const getEventFromChild = async function (childProcess, callId) {
+    if (childProcessHasExited(childProcess)) {
+        throw getChildExitError('Could not receive event from child process because it already exited.');
+    }
+    const messagePromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === callId });
+    const errorPromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === 'error' });
+    const exitPromise = pEvent(childProcess, 'exit', { multiArgs: true });
+    try {
+        return await Promise.race([getMessage(messagePromise), getError(errorPromise), getExit(exitPromise)]);
+    }
+    finally {
+        messagePromise.cancel();
+        errorPromise.cancel();
+        exitPromise.cancel();
+    }
+};
+const childProcessHasExited = function (childProcess) {
+    return !childProcess.connected || childProcess.signalCode !== null || childProcess.exitCode !== null;
+};
+const getMessage = async function (messagePromise) {
+    const [, response] = await messagePromise;
+    return response;
+};
+const getError = async function (errorPromise) {
+    const [, error] = await errorPromise;
+    throw jsonToError(error);
+};
+const getExit = async function (exitPromise) {
+    const [exitCode, signal] = await exitPromise;
+    throw getChildExitError(`Plugin exited with exit code ${exitCode} and signal ${signal}.`);
+};
+// Plugins should not terminate processes explicitly:
+//  - It prevents specifying error messages to the end users
+//  - It makes it impossible to distinguish between bugs (such as infinite loops) and user errors
+//  - It complicates child process orchestration. For example if an async operation
+//    of a previous event handler is still running, it would be aborted if another
+//    is terminating the process.
+const getChildExitError = function (message) {
+    const error = new Error(`${message}\n${EXIT_WARNING}`);
+    addErrorInfo(error, { type: 'ipc' });
+    return error;
+};
+const EXIT_WARNING = `The plugin might have exited due to a bug terminating the process, such as an infinite loop.
+The plugin might also have explicitly terminated the process, for example with process.exit().
+Plugin methods should instead:
+  - on success: return
+  - on failure: call utils.build.failPlugin() or utils.build.failBuild()`;
+// Send event from parent to child process
+const sendEventToChild = async function ({ childProcess, callId, eventName, payload, logs, verbose }) {
+    logSendingEventToChild(logs, verbose);
+    const payloadA = serializePayload(payload);
+    await promisify(childProcess.send.bind(childProcess))([callId, eventName, payloadA]);
+    logSentEventToChild(logs, verbose);
+};
+// Respond to events from parent to child process.
+// This runs forever until `childProcess.kill()` is called.
+// We need to use `new Promise()` and callbacks because this runs forever.
+export const getEventsFromParent = function (callback) {
+    return new Promise((resolve, reject) => {
+        process.on('message', async (message) => {
+            try {
+                const [callId, eventName, payload] = message;
+                const payloadA = parsePayload(payload);
+                return await callback(callId, eventName, payloadA);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+};
+// Send event from child to parent process
+export const sendEventToParent = async function (callId, payload, verbose, error) {
+    logSendingEventToParent(verbose, error);
+    await promisify(process.send.bind(process))([callId, payload]);
+};
+// Error static properties are not serializable through `child_process`
+// (which uses `v8.serialize()` under the hood) so we need to convert from/to
+// plain objects.
+const serializePayload = function ({ error = {}, error: { name } = {}, ...payload }) {
+    if (name === undefined) {
+        return payload;
+    }
+    const errorA = errorToJson(error);
+    return { ...payload, error: errorA };
+};
+const parsePayload = function ({ error = {}, error: { name } = {}, ...payload }) {
+    if (name === undefined) {
+        return payload;
+    }
+    const errorA = jsonToError(error);
+    return { ...payload, error: errorA };
+};

package/lib/plugins/list.js

@@ -0,0 +1,73 @@
+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';
+// 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 [];
+    }
+    const pluginsListUrlA = pluginsListUrl === undefined ? pluginsUrl : pluginsListUrl;
+    const pluginsList = await fetchPluginsList({ logs, pluginsListUrl: pluginsListUrlA });
+    const pluginsListA = normalizePluginsList(pluginsList);
+    logPluginsList({ pluginsList: pluginsListA, debug, logs });
+    return pluginsListA;
+};
+const fetchPluginsList = async function ({ logs, pluginsListUrl }) {
+    try {
+        const { body } = await got(pluginsListUrl, { responseType: 'json', timeout: PLUGINS_LIST_TIMEOUT });
+        if (!isValidPluginsList(body)) {
+            throw new Error(`Request succeeded but with an invalid response:\n${JSON.stringify(body, null, 2)}`);
+        }
+        return body;
+        // The Netlify Site should be up. This is a fallback.
+        // `oldPluginsList` might not contain the latest plugins versions:
+        //  - We should do `npm publish` as soon as a PR is merged in
+        //    `netlify/plugins` but it is possible we don't.
+        //  - Releasing it requires a @netlify/buld release, which requires itself a
+        //    buildbot release.
+    }
+    catch (error) {
+        logPluginsFetchError(logs, error.message);
+        return oldPluginsList;
+    }
+};
+// 1 minute HTTP request timeout
+const PLUGINS_LIST_TIMEOUT = 6e4;
+const isValidPluginsList = function (pluginsList) {
+    return Array.isArray(pluginsList) && pluginsList.every(isPlainObj);
+};
+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`.
+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 conditions = Object.entries(otherProperties).filter(isCondition).map(normalizeCondition);
+    return { version, migrationGuide, featureFlag, conditions };
+};
+const isCondition = function ([type]) {
+    return type in CONDITIONS;
+};
+const normalizeCondition = function ([type, condition]) {
+    return { type, condition };
+};

package/lib/plugins/load.js

@@ -0,0 +1,50 @@
+import { addErrorInfo } from '../error/info.js';
+import { addPluginLoadErrorStatus } from '../status/load_error.js';
+import { measureDuration } from '../time/main.js';
+import { callChild } from './ipc.js';
+// Retrieve all plugins steps
+// Can use either a module name or a file path to the plugin.
+export const loadPlugins = async function ({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, }) {
+    return pluginsOptions.length === 0
+        ? { pluginsSteps: [], timers }
+        : await loadAllPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose });
+};
+const tLoadAllPlugins = async function ({ pluginsOptions, childProcesses, packageJson, logs, debug, verbose }) {
+    const pluginsSteps = await Promise.all(pluginsOptions.map((pluginOptions, index) => loadPlugin(pluginOptions, { childProcesses, index, packageJson, logs, debug, verbose })));
+    const pluginsStepsA = pluginsSteps.flat();
+    return { pluginsSteps: pluginsStepsA };
+};
+// Only performed if there are some plugins
+const loadAllPlugins = measureDuration(tLoadAllPlugins, 'load_plugins');
+// Retrieve plugin steps for one plugin.
+// Do it by executing the plugin `load` event handler.
+const loadPlugin = async function ({ packageName, pluginPackageJson, pluginPackageJson: { version } = {}, pluginPath, inputs, loadedFrom, origin }, { childProcesses, index, packageJson, logs, debug, verbose }) {
+    const { childProcess } = childProcesses[index];
+    const loadEvent = 'load';
+    try {
+        const { events } = await callChild({
+            childProcess,
+            eventName: 'load',
+            payload: { pluginPath, inputs, packageJson, verbose },
+            logs,
+            verbose: false,
+        });
+        const pluginSteps = events.map((event) => ({
+            event,
+            packageName,
+            loadedFrom,
+            origin,
+            pluginPackageJson,
+            childProcess,
+        }));
+        return pluginSteps;
+    }
+    catch (error) {
+        addErrorInfo(error, {
+            plugin: { packageName, pluginPackageJson },
+            location: { event: loadEvent, packageName, loadedFrom, origin },
+        });
+        addPluginLoadErrorStatus({ error, packageName, version, debug });
+        throw error;
+    }
+};