@netlify/build 27.20.3 → 27.20.5

package/lib/plugins/ipc.js

@@ -1,31 +1,22 @@
-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'
-
+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
-}
-
+    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`
@@ -35,41 +26,36 @@ export const callChild = async function ({ childProcess, eventName, payload, log
 // 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()
-  }
-}
-
+    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
-}
-
+    return !childProcess.connected || childProcess.signalCode !== null || childProcess.exitCode !== null;
+};
 const getMessage = async function (messagePromise) {
-  const [, response] = await messagePromise
-  return response
-}
-
+    const [, response] = await messagePromise;
+    return response;
+};
 const getError = async function (errorPromise) {
-  const [, error] = await errorPromise
-  throw jsonToError(error)
-}
-
+    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}.`)
-}
-
+    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
@@ -77,67 +63,58 @@ const getExit = async function (exitPromise) {
 //    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 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()`
-
+  - 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)
-}
-
+    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)
-      }
-    })
-  })
-}
-
+    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])
-}
-
+    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 }
-}
-
+    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 }
-}
+    if (name === undefined) {
+        return payload;
+    }
+    const errorA = jsonToError(error);
+    return { ...payload, error: errorA };
+};

package/lib/plugins/list.js

@@ -1,11 +1,8 @@
-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'
-
+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
@@ -14,51 +11,44 @@ import { CONDITIONS } from './compatibility.js'
 // 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
-}
-
+    // 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)}`)
+    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;
     }
-
-    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 PLUGINS_LIST_TIMEOUT = 6e4;
 const isValidPluginsList = function (pluginsList) {
-  return Array.isArray(pluginsList) && pluginsList.every(isPlainObj)
-}
-
+    return Array.isArray(pluginsList) && pluginsList.every(isPlainObj);
+};
 const normalizePluginsList = function (pluginsList) {
-  return Object.fromEntries(pluginsList.map(normalizePluginItem))
-}
-
+    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.
@@ -67,20 +57,17 @@ const normalizePluginsList = function (pluginsList) {
 //  - 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 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 conditions = Object.entries(otherProperties).filter(isCondition).map(normalizeCondition);
+    return { version, migrationGuide, featureFlag, conditions };
+};
 const isCondition = function ([type]) {
-  return type in CONDITIONS
-}
-
+    return type in CONDITIONS;
+};
 const normalizeCondition = function ([type, condition]) {
-  return { type, condition }
-}
+    return { type, condition };
+};

package/lib/plugins/load.js

@@ -1,70 +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'
-
+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 })
-}
-
+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 }
-}
-
+    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')
-
+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
-  }
-}
+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;
+    }
+};

package/lib/plugins/manifest/check.js

@@ -1,106 +1,85 @@
-import { addErrorInfo } from '../../error/info.js'
-import { serializeObject } from '../../log/serialize.js'
-import { THEME } from '../../log/theme.js'
-
+import { addErrorInfo } from '../../error/info.js';
+import { serializeObject } from '../../log/serialize.js';
+import { THEME } from '../../log/theme.js';
 // Check that plugin inputs match the validation specified in "manifest.yml"
 // Also assign default values
-export const checkInputs = function ({
-  inputs,
-  manifest: { inputs: rules = [] },
-  packageName,
-  pluginPackageJson,
-  loadedFrom,
-  origin,
-}) {
-  try {
-    const inputsA = addDefaults(inputs, rules)
-    checkRequiredInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin })
-    checkUnknownInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin })
-    return inputsA
-  } catch (error) {
-    error.message = `${error.message}
+export const checkInputs = function ({ inputs, manifest: { inputs: rules = [] }, packageName, pluginPackageJson, loadedFrom, origin, }) {
+    try {
+        const inputsA = addDefaults(inputs, rules);
+        checkRequiredInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin });
+        checkUnknownInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin });
+        return inputsA;
+    }
+    catch (error) {
+        error.message = `${error.message}
 
 ${THEME.errorSubHeader('Plugin inputs')}
-${serializeObject(inputs)}`
-    throw error
-  }
-}
-
+${serializeObject(inputs)}`;
+        throw error;
+    }
+};
 // Add "inputs[*].default"
 const addDefaults = function (inputs, rules) {
-  const defaults = rules.filter(hasDefault).map(getDefault)
-  return Object.assign({}, ...defaults, inputs)
-}
-
+    const defaults = rules.filter(hasDefault).map(getDefault);
+    return Object.assign({}, ...defaults, inputs);
+};
 const hasDefault = function (rule) {
-  return rule.default !== undefined
-}
-
+    return rule.default !== undefined;
+};
 const getDefault = function ({ name, default: defaultValue }) {
-  return { [name]: defaultValue }
-}
-
+    return { [name]: defaultValue };
+};
 // Check "inputs[*].required"
 const checkRequiredInputs = function ({ inputs, rules, packageName, pluginPackageJson, loadedFrom, origin }) {
-  const missingInputs = rules.filter((rule) => isMissingRequired(inputs, rule))
-  if (missingInputs.length === 0) {
-    return
-  }
-
-  const names = missingInputs.map(getName)
-  const error = new Error(`Required inputs for plugin "${packageName}": ${names.join(', ')}`)
-  addInputError({ error, name: names[0], packageName, pluginPackageJson, loadedFrom, origin })
-  throw error
-}
-
+    const missingInputs = rules.filter((rule) => isMissingRequired(inputs, rule));
+    if (missingInputs.length === 0) {
+        return;
+    }
+    const names = missingInputs.map(getName);
+    const error = new Error(`Required inputs for plugin "${packageName}": ${names.join(', ')}`);
+    addInputError({ error, name: names[0], packageName, pluginPackageJson, loadedFrom, origin });
+    throw error;
+};
 const isMissingRequired = function (inputs, { name, required }) {
-  return required && inputs[name] === undefined
-}
-
+    return required && inputs[name] === undefined;
+};
 const getName = function ({ name }) {
-  return name
-}
-
+    return name;
+};
 // Check each "inputs[*].*" property for a specific input
 const checkUnknownInputs = function ({ inputs, rules, packageName, pluginPackageJson, loadedFrom, origin }) {
-  const knownInputs = rules.map(getName)
-  const unknownInputs = Object.keys(inputs).filter((name) => !knownInputs.includes(name))
-  if (unknownInputs.length === 0) {
-    return
-  }
-
-  const unknownInputsMessage = getUnknownInputsMessage({ packageName, knownInputs, unknownInputs })
-  const error = new Error(`${unknownInputsMessage}
+    const knownInputs = rules.map(getName);
+    const unknownInputs = Object.keys(inputs).filter((name) => !knownInputs.includes(name));
+    if (unknownInputs.length === 0) {
+        return;
+    }
+    const unknownInputsMessage = getUnknownInputsMessage({ packageName, knownInputs, unknownInputs });
+    const error = new Error(`${unknownInputsMessage}
 Check your plugin configuration to be sure that:
   - the input name is spelled correctly
   - the input is included in the plugin's available configuration options
-  - the plugin's input requirements have not changed`)
-  const [name] = unknownInputs
-  addInputError({ error, name, packageName, pluginPackageJson, loadedFrom, origin })
-  throw error
-}
-
+  - the plugin's input requirements have not changed`);
+    const [name] = unknownInputs;
+    addInputError({ error, name, packageName, pluginPackageJson, loadedFrom, origin });
+    throw error;
+};
 const getUnknownInputsMessage = function ({ packageName, knownInputs, unknownInputs }) {
-  const unknownInputsStr = unknownInputs.map(quoteWord).join(', ')
-
-  if (knownInputs.length === 0) {
-    return `Plugin "${packageName}" does not accept any inputs but you specified: ${unknownInputsStr}`
-  }
-
-  const knownInputsStr = knownInputs.map(quoteWord).join(', ')
-  return `Unknown inputs for plugin "${packageName}": ${unknownInputsStr}
-Plugin inputs should be one of: ${knownInputsStr}`
-}
-
+    const unknownInputsStr = unknownInputs.map(quoteWord).join(', ');
+    if (knownInputs.length === 0) {
+        return `Plugin "${packageName}" does not accept any inputs but you specified: ${unknownInputsStr}`;
+    }
+    const knownInputsStr = knownInputs.map(quoteWord).join(', ');
+    return `Unknown inputs for plugin "${packageName}": ${unknownInputsStr}
+Plugin inputs should be one of: ${knownInputsStr}`;
+};
 const quoteWord = function (word) {
-  return `"${word}"`
-}
-
+    return `"${word}"`;
+};
 // Add error information
 const addInputError = function ({ error, name, packageName, pluginPackageJson, loadedFrom, origin }) {
-  addErrorInfo(error, {
-    type: 'pluginInput',
-    plugin: { packageName, pluginPackageJson },
-    location: { event: 'load', packageName, input: name, loadedFrom, origin },
-  })
-}
+    addErrorInfo(error, {
+        type: 'pluginInput',
+        plugin: { packageName, pluginPackageJson },
+        location: { event: 'load', packageName, input: name, loadedFrom, origin },
+    });
+};