@netlify/build 27.20.4 → 27.20.6

package/lib/plugins/pinned_version.js

@@ -1,65 +1,41 @@
-import { handleBuildError } from '../error/handle.js'
-import { getMajorVersion } from '../utils/semver.js'
-
+import { handleBuildError } from '../error/handle.js';
+import { getMajorVersion } from '../utils/semver.js';
 // Retrieve plugin's pinned major versions by fetching the latest `PluginRun`
 // Only applies to `netlify.toml`-only installed plugins.
 export const addPinnedVersions = async function ({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }) {
-  if (!sendStatus || api === undefined || !siteId) {
-    return pluginsOptions
-  }
-
-  const packages = pluginsOptions.filter(shouldFetchPinVersion).map(getPackageName)
-  if (packages.length === 0) {
-    return pluginsOptions
-  }
-
-  const pluginRuns = await api.getLatestPluginRuns({ site_id: siteId, packages, state: 'success' })
-  const pluginsOptionsA = pluginsOptions.map((pluginOption) => addPinnedVersion(pluginOption, pluginRuns))
-  return pluginsOptionsA
-}
-
+    if (!sendStatus || api === undefined || !siteId) {
+        return pluginsOptions;
+    }
+    const packages = pluginsOptions.filter(shouldFetchPinVersion).map(getPackageName);
+    if (packages.length === 0) {
+        return pluginsOptions;
+    }
+    const pluginRuns = await api.getLatestPluginRuns({ site_id: siteId, packages, state: 'success' });
+    const pluginsOptionsA = pluginsOptions.map((pluginOption) => addPinnedVersion(pluginOption, pluginRuns));
+    return pluginsOptionsA;
+};
 const shouldFetchPinVersion = function ({ pinnedVersion, loadedFrom, origin }) {
-  return pinnedVersion === undefined && loadedFrom === 'auto_install' && origin === 'config'
-}
-
+    return pinnedVersion === undefined && loadedFrom === 'auto_install' && origin === 'config';
+};
 const getPackageName = function ({ packageName }) {
-  return packageName
-}
-
+    return packageName;
+};
 const addPinnedVersion = function (pluginOptions, pluginRuns) {
-  const foundPluginRun = pluginRuns.find((pluginRun) => pluginRun.package === pluginOptions.packageName)
-  if (foundPluginRun === undefined) {
-    return pluginOptions
-  }
-
-  const pinnedVersion = getMajorVersion(foundPluginRun.version)
-  return pinnedVersion === undefined ? pluginOptions : { ...pluginOptions, pinnedVersion }
-}
-
+    const foundPluginRun = pluginRuns.find((pluginRun) => pluginRun.package === pluginOptions.packageName);
+    if (foundPluginRun === undefined) {
+        return pluginOptions;
+    }
+    const pinnedVersion = getMajorVersion(foundPluginRun.version);
+    return pinnedVersion === undefined ? pluginOptions : { ...pluginOptions, pinnedVersion };
+};
 // Send an API request to pin plugins' major versions.
 // Only applies to UI-installed plugins.
-export const pinPlugins = async function ({
-  pluginsOptions,
-  failedPlugins,
-  api,
-  siteInfo: { id: siteId },
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  logs,
-  debug,
-  testOpts,
-  sendStatus,
-}) {
-  if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !siteId) {
-    return
-  }
-
-  const pluginsOptionsA = pluginsOptions.filter((pluginOptions) => shouldPinVersion({ pluginOptions, failedPlugins }))
-  await Promise.all(
-    pluginsOptionsA.map((pluginOptions) =>
-      pinPlugin({
+export const pinPlugins = async function ({ pluginsOptions, failedPlugins, api, siteInfo: { id: siteId }, childEnv, mode, netlifyConfig, errorMonitor, logs, debug, testOpts, sendStatus, }) {
+    if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !siteId) {
+        return;
+    }
+    const pluginsOptionsA = pluginsOptions.filter((pluginOptions) => shouldPinVersion({ pluginOptions, failedPlugins }));
+    await Promise.all(pluginsOptionsA.map((pluginOptions) => pinPlugin({
         pluginOptions,
         api,
         childEnv,
@@ -70,62 +46,38 @@ export const pinPlugins = async function ({
         debug,
         testOpts,
         siteId,
-      }),
-    ),
-  )
-}
-
+    })));
+};
 // Only pin version if:
 //  - the plugin's version has not been pinned yet
 //  - the plugin was installed in the UI
 //  - both the build and the plugin succeeded
-const shouldPinVersion = function ({
-  pluginOptions: { packageName, pinnedVersion, loadedFrom, origin },
-  failedPlugins,
-}) {
-  return (
-    pinnedVersion === undefined &&
-    loadedFrom === 'auto_install' &&
-    origin === 'ui' &&
-    !failedPlugins.includes(packageName)
-  )
-}
-
-const pinPlugin = async function ({
-  pluginOptions: {
-    packageName,
-    pluginPackageJson: { version },
-  },
-  api,
-  childEnv,
-  mode,
-  netlifyConfig,
-  errorMonitor,
-  logs,
-  debug,
-  testOpts,
-  siteId,
-}) {
-  const pinnedVersion = getMajorVersion(version)
-  try {
-    await api.updatePlugin({
-      package: encodeURIComponent(packageName),
-      site_id: siteId,
-      body: { pinned_version: pinnedVersion },
-    })
-    // Bitballoon API randomly fails with 502.
-    // Builds should be successful when this API call fails, but we still want
-    // to report the error both in logs and in error monitoring.
-  } catch (error) {
-    if (shouldIgnoreError(error)) {
-      return
+const shouldPinVersion = function ({ pluginOptions: { packageName, pinnedVersion, loadedFrom, origin }, failedPlugins, }) {
+    return (pinnedVersion === undefined &&
+        loadedFrom === 'auto_install' &&
+        origin === 'ui' &&
+        !failedPlugins.includes(packageName));
+};
+const pinPlugin = async function ({ pluginOptions: { packageName, pluginPackageJson: { version }, }, api, childEnv, mode, netlifyConfig, errorMonitor, logs, debug, testOpts, siteId, }) {
+    const pinnedVersion = getMajorVersion(version);
+    try {
+        await api.updatePlugin({
+            package: encodeURIComponent(packageName),
+            site_id: siteId,
+            body: { pinned_version: pinnedVersion },
+        });
+        // Bitballoon API randomly fails with 502.
+        // Builds should be successful when this API call fails, but we still want
+        // to report the error both in logs and in error monitoring.
+    }
+    catch (error) {
+        if (shouldIgnoreError(error)) {
+            return;
+        }
+        await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts });
     }
-
-    await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
-  }
-}
-
+};
 // Status is 404 if the plugin is uninstalled while the build is ongoing.
 const shouldIgnoreError = function ({ status }) {
-  return status === 404
-}
+    return status === 404;
+};

package/lib/plugins/resolve.js

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

package/lib/plugins/spawn.js

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

package/lib/plugins_core/add.js

@@ -1,49 +1,35 @@
-import { listCorePlugins, isCorePlugin } from './list.js'
-
+import { listCorePlugins, isCorePlugin } from './list.js';
 // Add core plugins and user plugins together.
 // Do not allow user override of core plugins.
 export const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
-  const corePlugins = listCorePlugins(constants)
-  const allCorePlugins = corePlugins
-    .map((corePlugin) => addCoreProperties(corePlugin, plugins))
-    .filter((corePlugin) => !isOptionalCore(corePlugin, plugins))
-  const userPlugins = plugins.filter(isUserPlugin)
-  const allPlugins = [...userPlugins, ...allCorePlugins]
-  const pluginsOptions = allPlugins.map(normalizePluginOptions)
-  return pluginsOptions
-}
-
+    const corePlugins = listCorePlugins(constants);
+    const allCorePlugins = corePlugins
+        .map((corePlugin) => addCoreProperties(corePlugin, plugins))
+        .filter((corePlugin) => !isOptionalCore(corePlugin, plugins));
+    const userPlugins = plugins.filter(isUserPlugin);
+    const allPlugins = [...userPlugins, ...allCorePlugins];
+    const pluginsOptions = allPlugins.map(normalizePluginOptions);
+    return pluginsOptions;
+};
 const addCoreProperties = function (corePlugin, plugins) {
-  const inputs = getCorePluginInputs(corePlugin, plugins)
-  return { ...corePlugin, inputs, loadedFrom: 'core', origin: 'core' }
-}
-
+    const inputs = getCorePluginInputs(corePlugin, plugins);
+    return { ...corePlugin, inputs, loadedFrom: 'core', origin: 'core' };
+};
 // Core plugins can get inputs too
 const getCorePluginInputs = function (corePlugin, plugins) {
-  const configuredCorePlugin = plugins.find((plugin) => plugin.package === corePlugin.package)
-  if (configuredCorePlugin === undefined) {
-    return {}
-  }
-
-  return configuredCorePlugin.inputs
-}
-
+    const configuredCorePlugin = plugins.find((plugin) => plugin.package === corePlugin.package);
+    if (configuredCorePlugin === undefined) {
+        return {};
+    }
+    return configuredCorePlugin.inputs;
+};
 // Optional core plugins requires user opt-in
 const isOptionalCore = function (pluginA, plugins) {
-  return pluginA.optional && plugins.every((pluginB) => pluginB.package !== pluginA.package)
-}
-
+    return pluginA.optional && plugins.every((pluginB) => pluginB.package !== pluginA.package);
+};
 const isUserPlugin = function (plugin) {
-  return !isCorePlugin(plugin.package)
-}
-
-const normalizePluginOptions = function ({
-  package: packageName,
-  pluginPath,
-  pinned_version: pinnedVersion,
-  loadedFrom,
-  origin,
-  inputs,
-}) {
-  return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs }
-}
+    return !isCorePlugin(plugin.package);
+};
+const normalizePluginOptions = function ({ package: packageName, pluginPath, pinned_version: pinnedVersion, loadedFrom, origin, inputs, }) {
+    return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs };
+};