@netlify/build 27.20.3 → 27.20.5

package/lib/error/monitor/normalize.js

@@ -2,95 +2,85 @@
 // unique IDs, etc. which defeats that grouping. So we normalize those to make
 // them consistent
 export const normalizeGroupingMessage = function (message, type) {
-  const messageA = removeDependenciesLogs(message, type)
-  const messageB = NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA)
-
-  // If this is a functions bundling error, we'll use additional normalization
-  // rules to group errors more aggressively.
-  if (type === 'functionsBundling') {
-    return FUNCTIONS_BUNDLING_REGEXPS.reduce(normalizeMessage, messageB)
-  }
-
-  return messageB
-}
-
+    const messageA = removeDependenciesLogs(message, type);
+    const messageB = NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA);
+    // If this is a functions bundling error, we'll use additional normalization
+    // rules to group errors more aggressively.
+    if (type === 'functionsBundling') {
+        return FUNCTIONS_BUNDLING_REGEXPS.reduce(normalizeMessage, messageB);
+    }
+    return messageB;
+};
 // Discard debug/info installation information
 const removeDependenciesLogs = function (message, type) {
-  if (type !== 'dependencies') {
-    return message
-  }
-
-  return message.split('\n').filter(isErrorLine).join('\n')
-}
-
+    if (type !== 'dependencies') {
+        return message;
+    }
+    return message.split('\n').filter(isErrorLine).join('\n');
+};
 const isErrorLine = function (line) {
-  return ERROR_LINES.some((errorLine) => line.startsWith(errorLine))
-}
-
+    return ERROR_LINES.some((errorLine) => line.startsWith(errorLine));
+};
 const ERROR_LINES = [
-  // Prefix for npm
-  'npm ERR!',
-  // Prefix for Yarn
-  'error',
-]
-
+    // Prefix for npm
+    'npm ERR!',
+    // Prefix for Yarn
+    'error',
+];
 const normalizeMessage = function (message, [regExp, replacement]) {
-  return message.replace(regExp, replacement)
-}
-
+    return message.replace(regExp, replacement);
+};
 const NORMALIZE_REGEXPS = [
-  // Base64 URL
-  [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
-  // File paths
-  [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
-  // Semantic versions
-  [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
-  [/version "[^"]+"/g, 'version "1.0.0"'],
-  // Cypress plugin prints the user's platform
-  [/^Platform: .*/gm, ''],
-  // URLs
-  [/https?:[\w.+~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
-  // Numbers, e.g. number of issues/problems
-  [/\d+/g, '0'],
-  // Hexadecimal strings
-  [/[\da-fA-F-]{6,}/g, 'hex'],
-  // On unknown inputs, we print the inputs
-  [/(does not accept any inputs but you specified: ).*/, '$1'],
-  [/(Unknown inputs for plugin).*/, '$1'],
-  [/(Plugin inputs should be one of: ).*/, '$1'],
-  // On required inputs, we print the inputs
-  [/^Plugin inputs[^]*/gm, ''],
-  [/(Required inputs for plugin).*/gm, '$1'],
-  // Netlify Functions validation check
-  [/(should target a directory, not a regular file):.*/, '$1'],
-  // zip-it-and-ship-it error when there is an `import()` but dependencies
-  // were not installed
-  [/(Cannot find module) '([^']+)'/g, "$1 'moduleName'"],
-  [/(A Netlify Function is using) "[^"]+"/g, '$1 "moduleName"'],
-  // Deploy upload errors include the filename
-  [/(Upload cancelled).*/g, '$1'],
-  [/(aborting upload of file).*/g, '$1'],
-  // netlify-plugin-inline-critical-css errors prints a list of file paths
-  [/Searched in: .*/g, ''],
-  // netlify-plugin-subfont prints font name in errors
-  [/(is not supported yet): .*/, '$1'],
-  // netlify-plugin-subfont prints generic information in every error that
-  // is highly build-specific
-  [/^(vers?ions|Plugin configuration|Subfont called with): {[^}]+}/gm, ''],
-  [/^Resolved entry points: \[[^\]]+]/gm, ''],
-  // netlify-plugin-minify-html parse error
-  [/(Parse Error):[^]*/, '$1'],
-  // Multiple empty lines
-  [/^\s*$/gm, ''],
-]
-
+    // Base64 URL
+    [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
+    // File paths
+    [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
+    // Semantic versions
+    [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
+    [/version "[^"]+"/g, 'version "1.0.0"'],
+    // Cypress plugin prints the user's platform
+    [/^Platform: .*/gm, ''],
+    // URLs
+    [/https?:[\w.+~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
+    // Numbers, e.g. number of issues/problems
+    [/\d+/g, '0'],
+    // Hexadecimal strings
+    [/[\da-fA-F-]{6,}/g, 'hex'],
+    // On unknown inputs, we print the inputs
+    [/(does not accept any inputs but you specified: ).*/, '$1'],
+    [/(Unknown inputs for plugin).*/, '$1'],
+    [/(Plugin inputs should be one of: ).*/, '$1'],
+    // On required inputs, we print the inputs
+    [/^Plugin inputs[^]*/gm, ''],
+    [/(Required inputs for plugin).*/gm, '$1'],
+    // Netlify Functions validation check
+    [/(should target a directory, not a regular file):.*/, '$1'],
+    // zip-it-and-ship-it error when there is an `import()` but dependencies
+    // were not installed
+    [/(Cannot find module) '([^']+)'/g, "$1 'moduleName'"],
+    [/(A Netlify Function is using) "[^"]+"/g, '$1 "moduleName"'],
+    // Deploy upload errors include the filename
+    [/(Upload cancelled).*/g, '$1'],
+    [/(aborting upload of file).*/g, '$1'],
+    // netlify-plugin-inline-critical-css errors prints a list of file paths
+    [/Searched in: .*/g, ''],
+    // netlify-plugin-subfont prints font name in errors
+    [/(is not supported yet): .*/, '$1'],
+    // netlify-plugin-subfont prints generic information in every error that
+    // is highly build-specific
+    [/^(vers?ions|Plugin configuration|Subfont called with): {[^}]+}/gm, ''],
+    [/^Resolved entry points: \[[^\]]+]/gm, ''],
+    // netlify-plugin-minify-html parse error
+    [/(Parse Error):[^]*/, '$1'],
+    // Multiple empty lines
+    [/^\s*$/gm, ''],
+];
 const FUNCTIONS_BUNDLING_REGEXPS = [
-  // String literals and identifiers
-  [/"([^"]+)"/g, '""'],
-  [/'([^']+)'/g, "''"],
-  [/`([^`]+)`/g, '``'],
-
-  // Rust crates
-  [/(?:Downloaded \S+ v[\d.]+\s*)+/gm, 'Downloaded crates'],
-  [/(?:Compiling \S+ v[\d.]+\s*)+/gm, 'Compiled crates'],
-]
+    // String literals and identifiers
+    [/"([^"]+)"/g, '""'],
+    [/'([^']+)'/g, "''"],
+    [/`([^`]+)`/g, '``'],
+    // Rust crates
+    [/(?:Downloaded \S+ v[\d.]+\s*)+/gm, 'Downloaded crates'],
+    [/(?:Compiling \S+ v[\d.]+\s*)+/gm, 'Compiled crates'],
+];

package/lib/error/monitor/print.js

@@ -1,42 +1,20 @@
-import { log } from '../../log/logger.js'
-
+import { log } from '../../log/logger.js';
 // Print event payload instead of sending actual request during tests
-export const printEventForTest = function (
-  { name: errorClass, message: errorMessage },
-  {
-    context,
-    groupingHash,
-    severity,
-    unhandled,
-    _metadata: {
-      location,
-      plugin: { packageName, homepage } = {},
-      pluginPackageJson,
-      tsConfig,
-      env: { BUILD_ID } = {},
-      other,
-    },
-  },
-  logs,
-) {
-  const eventString = JSON.stringify(
-    {
-      errorClass,
-      errorMessage,
-      context,
-      groupingHash,
-      severity,
-      unhandled,
-      location,
-      packageName,
-      pluginPackageJson: pluginPackageJson !== undefined,
-      homepage,
-      tsConfig,
-      BUILD_ID,
-      other,
-    },
-    null,
-    2,
-  )
-  log(logs, `\nError monitoring payload:\n${eventString}`)
-}
+export const printEventForTest = function ({ name: errorClass, message: errorMessage }, { context, groupingHash, severity, unhandled, _metadata: { location, plugin: { packageName, homepage } = {}, pluginPackageJson, tsConfig, env: { BUILD_ID } = {}, other, }, }, logs) {
+    const eventString = JSON.stringify({
+        errorClass,
+        errorMessage,
+        context,
+        groupingHash,
+        severity,
+        unhandled,
+        location,
+        packageName,
+        pluginPackageJson: pluginPackageJson !== undefined,
+        homepage,
+        tsConfig,
+        BUILD_ID,
+        other,
+    }, null, 2);
+    log(logs, `\nError monitoring payload:\n${eventString}`);
+};

package/lib/error/monitor/report.js

@@ -1,139 +1,120 @@
-import { type as osType, freemem, totalmem } from 'os'
-import { promisify } from 'util'
-
-import osName from 'os-name'
-
-import { getEnvMetadata } from '../../env/metadata.js'
-import { log } from '../../log/logger.js'
-import { parseErrorInfo } from '../parse/parse.js'
-import { getHomepage } from '../parse/plugin.js'
-
-import { getLocationMetadata } from './location.js'
-import { normalizeGroupingMessage } from './normalize.js'
-import { printEventForTest } from './print.js'
-
+import { type as osType, freemem, totalmem } from 'os';
+import { promisify } from 'util';
+import osName from 'os-name';
+import { getEnvMetadata } from '../../env/metadata.js';
+import { log } from '../../log/logger.js';
+import { parseErrorInfo } from '../parse/parse.js';
+import { getHomepage } from '../parse/plugin.js';
+import { getLocationMetadata } from './location.js';
+import { normalizeGroupingMessage } from './normalize.js';
+import { printEventForTest } from './print.js';
 // Report a build failure for monitoring purpose
 export const reportBuildError = async function ({ error, errorMonitor, childEnv, logs, testOpts }) {
-  if (errorMonitor === undefined) {
-    return
-  }
-
-  const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error)
-  const severityA = getSeverity(severity, errorInfo)
-  const groupA = getGroup(group, errorInfo)
-  const groupingHash = getGroupingHash(groupA, error, type, errorInfo)
-  const metadata = getMetadata(errorInfo, childEnv, groupingHash)
-  const app = getApp()
-  const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app })
-
-  const errorName = updateErrorName(error, type)
-  try {
-    await reportError({ errorMonitor, error, logs, testOpts, eventProps })
-  } finally {
-    error.name = errorName
-  }
-}
-
+    if (errorMonitor === undefined) {
+        return;
+    }
+    const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error);
+    const severityA = getSeverity(severity, errorInfo);
+    const groupA = getGroup(group, errorInfo);
+    const groupingHash = getGroupingHash(groupA, error, type, errorInfo);
+    const metadata = getMetadata(errorInfo, childEnv, groupingHash);
+    const app = getApp();
+    const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app });
+    const errorName = updateErrorName(error, type);
+    try {
+        await reportError({ errorMonitor, error, logs, testOpts, eventProps });
+    }
+    finally {
+        error.name = errorName;
+    }
+};
 // Plugin authors test their plugins as local plugins. Errors there are more
 // like development errors, and should be reported as `info` only.
 const getSeverity = function (severity, { location: { loadedFrom } = {} }) {
-  if (loadedFrom === 'local' || severity === 'none') {
-    return 'info'
-  }
-
-  return severity
-}
-
+    if (loadedFrom === 'local' || severity === 'none') {
+        return 'info';
+    }
+    return severity;
+};
 const getGroup = function (group, errorInfo) {
-  if (typeof group !== 'function') {
-    return group
-  }
-
-  return group(errorInfo)
-}
-
+    if (typeof group !== 'function') {
+        return group;
+    }
+    return group(errorInfo);
+};
 const getGroupingHash = function (group, error, type, errorInfo = {}) {
-  // If the error has a `normalizedMessage`, we use it as the grouping hash.
-  if (errorInfo.normalizedMessage) {
-    return errorInfo.normalizedMessage
-  }
-
-  const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error)
-  const messageA = normalizeGroupingMessage(message, type)
-  return `${group}\n${messageA}`
-}
-
+    // If the error has a `normalizedMessage`, we use it as the grouping hash.
+    if (errorInfo.normalizedMessage) {
+        return errorInfo.normalizedMessage;
+    }
+    const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error);
+    const messageA = normalizeGroupingMessage(message, type);
+    return `${group}\n${messageA}`;
+};
 const getMetadata = function ({ location, plugin, tsConfig }, childEnv, groupingHash) {
-  const pluginMetadata = getPluginMetadata({ location, plugin })
-  const envMetadata = getEnvMetadata(childEnv)
-  const locationMetadata = getLocationMetadata(location, envMetadata)
-  return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } }
-}
-
+    const pluginMetadata = getPluginMetadata({ location, plugin });
+    const envMetadata = getEnvMetadata(childEnv);
+    const locationMetadata = getLocationMetadata(location, envMetadata);
+    return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } };
+};
 const getPluginMetadata = function ({ location, plugin }) {
-  if (plugin === undefined) {
-    return {}
-  }
-
-  const { pluginPackageJson, ...pluginA } = plugin
-  const homepage = getHomepage(pluginPackageJson, location)
-  return { plugin: { ...pluginA, homepage }, pluginPackageJson }
-}
-
+    if (plugin === undefined) {
+        return {};
+    }
+    const { pluginPackageJson, ...pluginA } = plugin;
+    const homepage = getHomepage(pluginPackageJson, location);
+    return { plugin: { ...pluginA, homepage }, pluginPackageJson };
+};
 const getApp = function () {
-  return {
-    osName: osType(),
-    osVersion: osName(),
-    freeMemory: freemem(),
-    totalMemory: totalmem(),
-  }
-}
-
+    return {
+        osName: osType(),
+        osVersion: osName(),
+        freeMemory: freemem(),
+        totalMemory: totalmem(),
+    };
+};
 // `error.name` is shown proeminently in the Bugsnag UI. We need to update it to
 // match error `type` since it is more granular and useful.
 // But we change it back after Bugsnag is done reporting.
 const updateErrorName = function (error, type) {
-  const { name } = error
-  // This might fail if `name` is a getter or is non-writable.
-  try {
-    error.name = type
-  } catch {
-    // continue regardless error
-  }
-  return name
-}
-
+    const { name } = error;
+    // This might fail if `name` is a getter or is non-writable.
+    try {
+        error.name = type;
+    }
+    catch {
+        // continue regardless error
+    }
+    return name;
+};
 const reportError = async function ({ errorMonitor, error, logs, testOpts, eventProps }) {
-  if (testOpts.errorMonitor) {
-    printEventForTest(error, eventProps, logs)
-    return
-  }
-
-  try {
-    await promisify(errorMonitor.notify)(error, (event) => onError(event, eventProps))
-    // Failsafe
-  } catch {
-    log(logs, `Error monitor could not notify\n${error.stack}`)
-  }
-}
-
+    if (testOpts.errorMonitor) {
+        printEventForTest(error, eventProps, logs);
+        return;
+    }
+    try {
+        await promisify(errorMonitor.notify)(error, (event) => onError(event, eventProps));
+        // Failsafe
+    }
+    catch {
+        log(logs, `Error monitor could not notify\n${error.stack}`);
+    }
+};
 const getEventProps = function ({ severity, group, groupingHash, metadata, app }) {
-  // `unhandled` is used to calculate Releases "stabiity score", which is
-  // basically the percentage of unhandled errors. Since we handle all errors,
-  // we need to implement this according to error types.
-  const unhandled = severity === 'error'
-  return { severity, context: group, groupingHash, _metadata: metadata, app, unhandled }
-}
-
+    // `unhandled` is used to calculate Releases "stabiity score", which is
+    // basically the percentage of unhandled errors. Since we handle all errors,
+    // we need to implement this according to error types.
+    const unhandled = severity === 'error';
+    return { severity, context: group, groupingHash, _metadata: metadata, app, unhandled };
+};
 // Add more information to Bugsnag events
 const onError = function (event, eventProps) {
-  // Bugsnag client requires directly mutating the `event`
-  Object.assign(event, {
-    ...eventProps,
-    unhandled: event.unhandled || eventProps.unhandled,
-
-    _metadata: { ...event._metadata, ...eventProps._metadata },
-    app: { ...event.app, ...eventProps.app },
-  })
-  return true
-}
+    // Bugsnag client requires directly mutating the `event`
+    Object.assign(event, {
+        ...eventProps,
+        unhandled: event.unhandled || eventProps.unhandled,
+        _metadata: { ...event._metadata, ...eventProps._metadata },
+        app: { ...event.app, ...eventProps.app },
+    });
+    return true;
+};

package/lib/error/monitor/start.js

@@ -1,71 +1,58 @@
-import { fileURLToPath } from 'url'
-
-import Bugsnag from '@bugsnag/js'
-import memoizeOne from 'memoize-one'
-
-import { log } from '../../log/logger.js'
-import { ROOT_PACKAGE_JSON } from '../../utils/json.js'
-
-const projectRoot = fileURLToPath(new URL('../../..', import.meta.url))
-
+import { fileURLToPath } from 'url';
+import Bugsnag from '@bugsnag/js';
+import memoizeOne from 'memoize-one';
+import { log } from '../../log/logger.js';
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js';
+const projectRoot = fileURLToPath(new URL('../../..', import.meta.url));
 // Start a client to monitor errors
 export const startErrorMonitor = function ({ flags: { mode }, logs, bugsnagKey }) {
-  if (!bugsnagKey) {
-    return
-  }
-
-  const isTest = isBugsnagTest(bugsnagKey)
-  const releaseStage = getReleaseStage(mode)
-  const logger = getLogger(logs, isTest)
-  try {
-    const errorMonitor = startBugsnag({
-      apiKey: bugsnagKey,
-      appVersion: `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`,
-      appType: ROOT_PACKAGE_JSON.name,
-      releaseStage,
-      logger,
-      projectRoot,
-    })
-
-    // Allows knowing the percentage of failed builds per release
-    if (!isTest) {
-      errorMonitor.startSession()
+    if (!bugsnagKey) {
+        return;
     }
-
-    return errorMonitor
-    // Failsafe
-  } catch (error) {
-    log(logs, `Error monitor could not start\n${error.stack}`)
-  }
-}
-
+    const isTest = isBugsnagTest(bugsnagKey);
+    const releaseStage = getReleaseStage(mode);
+    const logger = getLogger(logs, isTest);
+    try {
+        const errorMonitor = startBugsnag({
+            apiKey: bugsnagKey,
+            appVersion: `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`,
+            appType: ROOT_PACKAGE_JSON.name,
+            releaseStage,
+            logger,
+            projectRoot,
+        });
+        // Allows knowing the percentage of failed builds per release
+        if (!isTest) {
+            errorMonitor.startSession();
+        }
+        return errorMonitor;
+        // Failsafe
+    }
+    catch (error) {
+        log(logs, `Error monitor could not start\n${error.stack}`);
+    }
+};
 const isBugsnagTest = function (bugsnagKey) {
-  return bugsnagKey === BUGSNAG_TEST_KEY
-}
-
-const BUGSNAG_TEST_KEY = '00000000000000000000000000000000'
-
+    return bugsnagKey === BUGSNAG_TEST_KEY;
+};
+const BUGSNAG_TEST_KEY = '00000000000000000000000000000000';
 // Bugsnag.start() caches a global instance and warns on duplicate calls.
 // This ensures the warning message is not shown when calling the main function
 // several times.
-const startBugsnag = memoizeOne(Bugsnag.start.bind(Bugsnag), () => true)
-
+const startBugsnag = memoizeOne(Bugsnag.start.bind(Bugsnag), () => true);
 // Based the release stage on the `mode`
 const getReleaseStage = function (mode = DEFAULT_RELEASE_STAGE) {
-  return mode
-}
-
-const DEFAULT_RELEASE_STAGE = 'unknown'
-
+    return mode;
+};
+const DEFAULT_RELEASE_STAGE = 'unknown';
 // We don't want Bugsnag logs except on warnings/errors.
 // We also want to use our own `log` utility, unprefixed.
 // In tests, we don't print Bugsnag because it sometimes randomly fails to
 // send sessions, which prints warning messags in test snapshots.
 const getLogger = function (logs, isTest) {
-  const logFunc = isTest ? noop : log.bind(null, logs)
-  return { debug: noop, info: noop, warn: logFunc, error: logFunc }
-}
-
+    const logFunc = isTest ? noop : log.bind(null, logs);
+    return { debug: noop, info: noop, warn: logFunc, error: logFunc };
+};
 const noop = function () {
-  // this is a noop function
-}
+    // this is a noop function
+};