@netlify/build 27.20.4 → 27.20.6

package/lib/log/old_version.js

@@ -1,41 +1,32 @@
-import { stdout } from 'process'
-
-import UpdateNotifier from 'update-notifier'
-
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
+import { stdout } from 'process';
+import UpdateNotifier from 'update-notifier';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 // Many build errors happen in local builds that do not use the latest version
 // of `@netlify/build`. We print a warning message on those.
 // We only print this when Netlify CLI has been used. Programmatic usage might
 // come from a deep dependency calling `@netlify/build` and user might not be
 // able to take any upgrade action, making the message noisy.
 export const logOldCliVersionError = function ({ mode, testOpts }) {
-  if (mode !== 'cli') {
-    return
-  }
-
-  const corePackageJson = getCorePackageJson(testOpts)
-  UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
-    message: OLD_VERSION_MESSAGE,
-    shouldNotifyInNpmScript: true,
-  })
-}
-
+    if (mode !== 'cli') {
+        return;
+    }
+    const corePackageJson = getCorePackageJson(testOpts);
+    UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
+        message: OLD_VERSION_MESSAGE,
+        shouldNotifyInNpmScript: true,
+    });
+};
 const getCorePackageJson = function (testOpts) {
-  // TODO: Find a way to test this without injecting code in the `src/`
-  if (testOpts.oldCliLogs) {
-    // `update-notifier` does not do anything if not in a TTY.
-    // In tests, we need to monkey patch this
-    // Mutation is required due to how `stdout.isTTY` works
-
-    stdout.isTTY = true
-
-    return { ...ROOT_PACKAGE_JSON, version: '0.0.1' }
-  }
-
-  return ROOT_PACKAGE_JSON
-}
-
+    // TODO: Find a way to test this without injecting code in the `src/`
+    if (testOpts.oldCliLogs) {
+        // `update-notifier` does not do anything if not in a TTY.
+        // In tests, we need to monkey patch this
+        // Mutation is required due to how `stdout.isTTY` works
+        stdout.isTTY = true;
+        return { ...ROOT_PACKAGE_JSON, version: '0.0.1' };
+    }
+    return ROOT_PACKAGE_JSON;
+};
 const OLD_VERSION_MESSAGE = `Please update netlify-cli to its latest version.
 If netlify-cli is already the latest version,
-please update your dependencies lock file instead.`
+please update your dependencies lock file instead.`;

package/lib/log/serialize.js

@@ -1,13 +1,10 @@
-import { dump } from 'js-yaml'
-
+import { dump } from 'js-yaml';
 export const serializeObject = function (object) {
-  return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd()
-}
-
+    return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd();
+};
 export const serializeArray = function (array) {
-  return array.map(addDash).join('\n')
-}
-
+    return array.map(addDash).join('\n');
+};
 const addDash = function (string) {
-  return ` - ${string}`
-}
+    return ` - ${string}`;
+};

package/lib/log/stream.js

@@ -1,85 +1,68 @@
-import { stdout, stderr } from 'process'
-import { promisify } from 'util'
-
+import { stdout, stderr } from 'process';
+import { promisify } from 'util';
 // TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
+const pSetTimeout = promisify(setTimeout);
 // We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
 // which solves many problems. However we can only do it in build.command.
 // Plugins have several events, so need to be switch on and off instead.
 // In buffer mode (`logs` not `undefined`), `pipe` is necessary.
 export const getBuildCommandStdio = function (logs) {
-  if (logs !== undefined) {
-    return 'pipe'
-  }
-
-  return 'inherit'
-}
-
+    if (logs !== undefined) {
+        return 'pipe';
+    }
+    return 'inherit';
+};
 // Add build command output
 export const handleBuildCommandOutput = function ({ stdout: commandStdout, stderr: commandStderr }, logs) {
-  if (logs === undefined) {
-    return
-  }
-
-  pushBuildCommandOutput(commandStdout, logs.stdout)
-  pushBuildCommandOutput(commandStderr, logs.stderr)
-}
-
+    if (logs === undefined) {
+        return;
+    }
+    pushBuildCommandOutput(commandStdout, logs.stdout);
+    pushBuildCommandOutput(commandStderr, logs.stderr);
+};
 const pushBuildCommandOutput = function (output, logsArray) {
-  if (output === '') {
-    return
-  }
-
-  logsArray.push(output)
-}
-
+    if (output === '') {
+        return;
+    }
+    logsArray.push(output);
+};
 // Start plugin step output
 export const pipePluginOutput = function (childProcess, logs) {
-  if (logs === undefined) {
-    return streamOutput(childProcess)
-  }
-
-  return pushOutputToLogs(childProcess, logs)
-}
-
+    if (logs === undefined) {
+        return streamOutput(childProcess);
+    }
+    return pushOutputToLogs(childProcess, logs);
+};
 // Stop streaming/buffering plugin step output
 export const unpipePluginOutput = async function (childProcess, logs, listeners) {
-  // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
-  await pSetTimeout(0)
-
-  if (logs === undefined) {
-    return unstreamOutput(childProcess)
-  }
-
-  unpushOutputToLogs(childProcess, logs, listeners)
-}
-
+    // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
+    await pSetTimeout(0);
+    if (logs === undefined) {
+        return unstreamOutput(childProcess);
+    }
+    unpushOutputToLogs(childProcess, logs, listeners);
+};
 // Usually, we stream stdout/stderr because it is more efficient
 const streamOutput = function (childProcess) {
-  childProcess.stdout.pipe(stdout)
-  childProcess.stderr.pipe(stderr)
-}
-
+    childProcess.stdout.pipe(stdout);
+    childProcess.stderr.pipe(stderr);
+};
 const unstreamOutput = function (childProcess) {
-  childProcess.stdout.unpipe(stdout)
-  childProcess.stderr.unpipe(stderr)
-}
-
+    childProcess.stdout.unpipe(stdout);
+    childProcess.stderr.unpipe(stderr);
+};
 // In tests, we push to the `logs` array instead
 const pushOutputToLogs = function (childProcess, logs) {
-  const stdoutListener = logsListener.bind(null, logs.stdout)
-  const stderrListener = logsListener.bind(null, logs.stderr)
-  childProcess.stdout.on('data', stdoutListener)
-  childProcess.stderr.on('data', stderrListener)
-  return { stdoutListener, stderrListener }
-}
-
+    const stdoutListener = logsListener.bind(null, logs.stdout);
+    const stderrListener = logsListener.bind(null, logs.stderr);
+    childProcess.stdout.on('data', stdoutListener);
+    childProcess.stderr.on('data', stderrListener);
+    return { stdoutListener, stderrListener };
+};
 const logsListener = function (logs, chunk) {
-  logs.push(chunk.toString().trimEnd())
-}
-
+    logs.push(chunk.toString().trimEnd());
+};
 const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
-  childProcess.stdout.removeListener('data', stdoutListener)
-  childProcess.stderr.removeListener('data', stderrListener)
-}
+    childProcess.stdout.removeListener('data', stdoutListener);
+    childProcess.stderr.removeListener('data', stderrListener);
+};

package/lib/log/theme.js

@@ -1,26 +1,25 @@
-import chalk from 'chalk'
-
+import chalk from 'chalk';
 // Color theme. Please use this instead of requiring chalk directly, to ensure
 // consistent colors.
 export const THEME = {
-  // Main headers
-  header: chalk.cyanBright.bold,
-  // Single lines used as subheaders
-  subHeader: chalk.cyan.bold,
-  // One of several words that should be highlighted inside a line
-  highlightWords: chalk.cyan,
-  // Same for errors
-  errorHeader: chalk.redBright.bold,
-  errorSubHeader: chalk.red.bold,
-  errorLine: chalk.redBright,
-  errorHighlightWords: chalk.redBright.bold,
-  // Same for warnings
-  warningHeader: chalk.yellowBright.bold,
-  warningSubHeader: chalk.yellow.bold,
-  warningLine: chalk.yellowBright,
-  warningHighlightWords: chalk.yellowBright.bold,
-  // One of several words that should be dimmed inside a line
-  dimWords: chalk.gray,
-  // No colors
-  none: (string) => string,
-}
+    // Main headers
+    header: chalk.cyanBright.bold,
+    // Single lines used as subheaders
+    subHeader: chalk.cyan.bold,
+    // One of several words that should be highlighted inside a line
+    highlightWords: chalk.cyan,
+    // Same for errors
+    errorHeader: chalk.redBright.bold,
+    errorSubHeader: chalk.red.bold,
+    errorLine: chalk.redBright,
+    errorHighlightWords: chalk.redBright.bold,
+    // Same for warnings
+    warningHeader: chalk.yellowBright.bold,
+    warningSubHeader: chalk.yellow.bold,
+    warningLine: chalk.yellowBright,
+    warningHighlightWords: chalk.yellowBright.bold,
+    // One of several words that should be dimmed inside a line
+    dimWords: chalk.gray,
+    // No colors
+    none: (string) => string,
+};

package/lib/plugins/child/diff.js

@@ -1,15 +1,11 @@
-import { isDeepStrictEqual } from 'util'
-
-import isPlainObj from 'is-plain-obj'
-import rfdc from 'rfdc'
-
-const clone = rfdc()
-
+import { isDeepStrictEqual } from 'util';
+import isPlainObj from 'is-plain-obj';
+import rfdc from 'rfdc';
+const clone = rfdc();
 // Copy `netlifyConfig` so we can compare before/after mutating it
 export const cloneNetlifyConfig = function (netlifyConfig) {
-  return clone(netlifyConfig)
-}
-
+    return clone(netlifyConfig);
+};
 // Diff `netlifyConfig` before and after mutating it to retrieve an array of
 // `configMutations` objects.
 // We need to keep track of the changes on `netlifyConfig` so they can be
@@ -19,37 +15,32 @@ export const cloneNetlifyConfig = function (netlifyConfig) {
 //    run `@netlify/config` to normalize and validate the new values
 // `configMutations` is passed to parent process as JSON
 export const getConfigMutations = function (netlifyConfig, netlifyConfigCopy, event) {
-  const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, [])
-  return configMutations.map((configMutation) => getConfigMutation(configMutation, event))
-}
-
+    const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, []);
+    return configMutations.map((configMutation) => getConfigMutation(configMutation, event));
+};
 // We only recurse over plain objects, not arrays. Which means array properties
 // can only be modified all at once.
 const diffObjects = function (objA, objB, parentKeys) {
-  const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])]
-  return allKeys.flatMap((key) => {
-    const valueA = objA[key]
-    const valueB = objB[key]
-    const keys = [...parentKeys, key]
-
-    if (isPlainObj(valueA) && isPlainObj(valueB)) {
-      return diffObjects(valueA, valueB, keys)
-    }
-
-    if (isDeepStrictEqual(valueA, valueB)) {
-      return []
-    }
-
-    return [{ keys, value: valueB }]
-  })
-}
-
+    const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])];
+    return allKeys.flatMap((key) => {
+        const valueA = objA[key];
+        const valueB = objB[key];
+        const keys = [...parentKeys, key];
+        if (isPlainObj(valueA) && isPlainObj(valueB)) {
+            return diffObjects(valueA, valueB, keys);
+        }
+        if (isDeepStrictEqual(valueA, valueB)) {
+            return [];
+        }
+        return [{ keys, value: valueB }];
+    });
+};
 const getConfigMutation = function ({ keys, value }, event) {
-  const serializedKeys = keys.map(String)
-  return {
-    keys: serializedKeys,
-    keysString: serializedKeys.join('.'),
-    value,
-    event,
-  }
-}
+    const serializedKeys = keys.map(String);
+    return {
+        keys: serializedKeys,
+        keysString: serializedKeys.join('.'),
+        value,
+        event,
+    };
+};

package/lib/plugins/child/error.js

@@ -1,32 +1,26 @@
-import logProcessErrors from 'log-process-errors'
-
-import { errorToJson } from '../../error/build.js'
-import { addDefaultErrorInfo, isBuildError } from '../../error/info.js'
-import { normalizeError } from '../../error/parse/normalize.js'
-import { sendEventToParent } from '../ipc.js'
-
+import logProcessErrors from 'log-process-errors';
+import { errorToJson } from '../../error/build.js';
+import { addDefaultErrorInfo, isBuildError } from '../../error/info.js';
+import { normalizeError } from '../../error/parse/normalize.js';
+import { sendEventToParent } from '../ipc.js';
 // Handle any top-level error and communicate it back to parent
 export const handleError = async function (error, verbose) {
-  const errorA = normalizeError(error)
-  addDefaultErrorInfo(errorA, { type: 'pluginInternal' })
-  const errorPayload = errorToJson(errorA)
-  await sendEventToParent('error', errorPayload, verbose, errorA)
-}
-
+    const errorA = normalizeError(error);
+    addDefaultErrorInfo(errorA, { type: 'pluginInternal' });
+    const errorPayload = errorToJson(errorA);
+    await sendEventToParent('error', errorPayload, verbose, errorA);
+};
 // On uncaught exceptions and unhandled rejections, print the stack trace.
 // Also, prevent child processes from crashing on uncaught exceptions.
 export const handleProcessErrors = function () {
-  logProcessErrors({ log: handleProcessError, exitOn: [] })
-}
-
+    logProcessErrors({ log: handleProcessError, exitOn: [] });
+};
 const handleProcessError = async function (error, level, originalError) {
-  if (level !== 'error') {
-    console[level](error)
-    return
-  }
-
-  // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
-  const errorA = isBuildError(originalError) ? originalError : error
-
-  await handleError(errorA)
-}
+    if (level !== 'error') {
+        console[level](error);
+        return;
+    }
+    // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
+    const errorA = isBuildError(originalError) ? originalError : error;
+    await handleError(errorA);
+};

package/lib/plugins/child/lazy.js

@@ -1,18 +1,15 @@
-import memoizeOne from 'memoize-one'
-
+import memoizeOne from 'memoize-one';
 // Add a `object[propName]` whose value is the return value of `getFunc()`, but
 // is only retrieved when accessed.
 export const addLazyProp = function (object, propName, getFunc) {
-  const mGetFunc = memoizeOne(getFunc, returnTrue)
-  // Mutation is required due to the usage of `Object.defineProperty()`
-
-  Object.defineProperty(object, propName, {
-    get: mGetFunc,
-    enumerable: true,
-    configurable: true,
-  })
-}
-
+    const mGetFunc = memoizeOne(getFunc, returnTrue);
+    // Mutation is required due to the usage of `Object.defineProperty()`
+    Object.defineProperty(object, propName, {
+        get: mGetFunc,
+        enumerable: true,
+        configurable: true,
+    });
+};
 const returnTrue = function () {
-  return true
-}
+    return true;
+};

package/lib/plugins/child/load.js

@@ -1,29 +1,22 @@
-import filterObj from 'filter-obj'
-
-import { getLogic } from './logic.js'
-import { registerTypeScript } from './typescript.js'
-import { validatePlugin } from './validate.js'
-
+import filterObj from 'filter-obj';
+import { getLogic } from './logic.js';
+import { registerTypeScript } from './typescript.js';
+import { validatePlugin } from './validate.js';
 // Load context passed to every plugin method.
 // This also requires the plugin file and fire its top-level function.
 // This also validates the plugin.
 // Do it when parent requests it using the `load` event.
 // Also figure out the list of plugin steps. This is also passed to the parent.
 export const load = async function ({ pluginPath, inputs, packageJson, verbose }) {
-  const tsNodeService = registerTypeScript(pluginPath)
-  const logic = await getLogic({ pluginPath, inputs, tsNodeService })
-
-  validatePlugin(logic)
-
-  const methods = filterObj(logic, isEventHandler)
-  const events = Object.keys(methods)
-
-  // Context passed to every event handler
-  const context = { methods, inputs, packageJson, verbose }
-
-  return { events, context }
-}
-
+    const tsNodeService = registerTypeScript(pluginPath);
+    const logic = await getLogic({ pluginPath, inputs, tsNodeService });
+    validatePlugin(logic);
+    const methods = filterObj(logic, isEventHandler);
+    const events = Object.keys(methods);
+    // Context passed to every event handler
+    const context = { methods, inputs, packageJson, verbose };
+    return { events, context };
+};
 const isEventHandler = function (event, value) {
-  return typeof value === 'function'
-}
+    return typeof value === 'function';
+};

package/lib/plugins/child/logic.js

@@ -1,64 +1,57 @@
-import { createRequire } from 'module'
-import { pathToFileURL } from 'url'
-
-import { ROOT_PACKAGE_JSON } from '../../utils/json.js'
-import { DEV_EVENTS, EVENTS } from '../events.js'
-
-import { addTsErrorInfo } from './typescript.js'
-
-const require = createRequire(import.meta.url)
-
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js';
+import { DEV_EVENTS, EVENTS } from '../events.js';
+import { addTsErrorInfo } from './typescript.js';
+const require = createRequire(import.meta.url);
 // Require the plugin file and fire its top-level function.
 // The returned object is the `logic` which includes all event handlers.
 export const getLogic = async function ({ pluginPath, inputs, tsNodeService }) {
-  const logic = await importLogic(pluginPath, tsNodeService)
-  const logicA = loadLogic({ logic, inputs })
-  return logicA
-}
-
+    const logic = await importLogic(pluginPath, tsNodeService);
+    const logicA = loadLogic({ logic, inputs });
+    return logicA;
+};
 const importLogic = async function (pluginPath, tsNodeService) {
-  try {
-    // `ts-node` is not available programmatically for pure ES modules yet,
-    // which is currently making it impossible for local plugins to use both
-    // pure ES modules and TypeScript.
-    if (tsNodeService !== undefined) {
-      return require(pluginPath)
+    try {
+        // `ts-node` is not available programmatically for pure ES modules yet,
+        // which is currently making it impossible for local plugins to use both
+        // pure ES modules and TypeScript.
+        if (tsNodeService !== undefined) {
+            return require(pluginPath);
+        }
+        // `pluginPath` is an absolute file path but `import()` needs URLs.
+        // Converting those with `pathToFileURL()` is needed especially on Windows
+        // where the drive letter would not work with `import()`.
+        const returnValue = await import(pathToFileURL(pluginPath));
+        // Plugins should use named exports, but we still support default exports
+        // for backward compatibility with CommonJS
+        return returnValue.default === undefined ? returnValue : returnValue.default;
     }
-
-    // `pluginPath` is an absolute file path but `import()` needs URLs.
-    // Converting those with `pathToFileURL()` is needed especially on Windows
-    // where the drive letter would not work with `import()`.
-    const returnValue = await import(pathToFileURL(pluginPath))
-    // Plugins should use named exports, but we still support default exports
-    // for backward compatibility with CommonJS
-    return returnValue.default === undefined ? returnValue : returnValue.default
-  } catch (error) {
-    addTsErrorInfo(error, tsNodeService)
-    // We must change `error.stack` instead of `error.message` because some
-    // errors thrown from `import()` access `error.stack` before throwing.
-    // `error.stack` is lazily instantiated by Node.js, so changing
-    // `error.message` afterwards would not modify `error.stack`. Therefore, the
-    // resulting stack trace, which is printed in the build logs, would not
-    // include the additional message prefix.
-    error.stack = `Could not import plugin:\n${error.stack}`
-    throw error
-  }
-}
-
+    catch (error) {
+        addTsErrorInfo(error, tsNodeService);
+        // We must change `error.stack` instead of `error.message` because some
+        // errors thrown from `import()` access `error.stack` before throwing.
+        // `error.stack` is lazily instantiated by Node.js, so changing
+        // `error.message` afterwards would not modify `error.stack`. Therefore, the
+        // resulting stack trace, which is printed in the build logs, would not
+        // include the additional message prefix.
+        error.stack = `Could not import plugin:\n${error.stack}`;
+        throw error;
+    }
+};
 const loadLogic = function ({ logic, inputs }) {
-  if (typeof logic !== 'function') {
-    return logic
-  }
-
-  const metadata = {
-    events: new Set([...DEV_EVENTS, ...EVENTS]),
-    version: ROOT_PACKAGE_JSON.version,
-  }
-
-  try {
-    return logic(inputs, metadata)
-  } catch (error) {
-    error.message = `Could not load plugin:\n${error.message}`
-    throw error
-  }
-}
+    if (typeof logic !== 'function') {
+        return logic;
+    }
+    const metadata = {
+        events: new Set([...DEV_EVENTS, ...EVENTS]),
+        version: ROOT_PACKAGE_JSON.version,
+    };
+    try {
+        return logic(inputs, metadata);
+    }
+    catch (error) {
+        error.message = `Could not load plugin:\n${error.message}`;
+        throw error;
+    }
+};