@netlify/build 0.4.48 → 1.0.0-dl-test

package/lib/error/monitor/start.js

@@ -0,0 +1,61 @@
+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 (config) {
+    const { flags: { mode }, logs, bugsnagKey, } = config;
+    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();
+        }
+        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';
+// 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.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+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';
+// 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 noop = function () {
+    // this is a noop function
+};

package/lib/error/parse/clean_stack.js

@@ -0,0 +1,70 @@
+import { cwd } from 'process';
+import cleanStack from 'clean-stack';
+import stripAnsi from 'strip-ansi';
+// Clean stack traces:
+//  - remove our internal code, e.g. the logic spawning plugins
+//  - remove node modules and Node.js internals
+//  - strip process.cwd()
+//  - remove colors
+// Keep non stack trace lines as is.
+// We do not use libraries that patch `Error.prepareStackTrace()` because they
+// tend to create issues.
+export const cleanStacks = function ({ stack, rawStack, debug }) {
+    if (stack === undefined) {
+        return;
+    }
+    // Internal errors / bugs keep their full stack trace
+    // Same in debug mode
+    if (rawStack || debug) {
+        return stack;
+    }
+    return stack.split('\n').reduce(cleanStackLine, '').replace(INITIAL_NEWLINES, '');
+};
+const cleanStackLine = function (lines, line) {
+    const lineA = line.replace(getCwd(), '');
+    const lineB = stripAnsi(lineA);
+    if (!STACK_LINE_REGEXP.test(lineB)) {
+        return `${lines}\n${lineA}`;
+    }
+    if (shouldRemoveStackLine(lineB)) {
+        return lines;
+    }
+    const lineC = cleanStack(lineB);
+    if (lineC === '') {
+        return lines;
+    }
+    return `${lines}\n${lineC}`;
+};
+// `process.cwd()` can sometimes fail: directory name too long, current
+// directory has been removed, access denied.
+const getCwd = function () {
+    try {
+        return cwd();
+    }
+    catch {
+        return '';
+    }
+};
+// Check if a line is part of a stack trace
+const STACK_LINE_REGEXP = /^\s+at /;
+const shouldRemoveStackLine = function (line) {
+    const lineA = normalizePathSlashes(line);
+    return INTERNAL_STACK_STRINGS.some((stackString) => lineA.includes(stackString)) || INTERNAL_STACK_REGEXP.test(lineA);
+};
+const INTERNAL_STACK_STRINGS = [
+    // Anonymous function
+    '<anonymous>',
+    '(index 0)',
+    // nyc internal code
+    'node_modules/append-transform',
+    'node_modules/signal-exit',
+    // Node internals
+    '(node:',
+];
+// This is only needed for local builds and tests
+const INTERNAL_STACK_REGEXP = /(lib\/|tests\/helpers\/|tests\/.*\/tests.js|node_modules)/;
+const INITIAL_NEWLINES = /^\n+/;
+const normalizePathSlashes = function (line) {
+    return line.replace(BACKLASH_REGEXP, '/');
+};
+const BACKLASH_REGEXP = /\\/g;

package/lib/error/parse/location.js

@@ -0,0 +1,50 @@
+import { getBuildCommandDescription, getPluginOrigin } from '../../log/description.js';
+// Retrieve an error's location to print in logs.
+// Each error type has its own logic (or none if there's no location to print).
+export const getLocationInfo = function ({ stack, location, locationType }) {
+    // No location to print
+    if (locationType === undefined && stack === undefined) {
+        return;
+    }
+    // The location is only the stack trace
+    if (locationType === undefined) {
+        return stack;
+    }
+    const locationString = LOCATIONS[locationType](location);
+    return [locationString, stack].filter(Boolean).join('\n');
+};
+const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin }) {
+    const description = getBuildCommandDescription(buildCommandOrigin);
+    return `In ${description}:
+${buildCommand}`;
+};
+const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
+    if (functionType === 'edge') {
+        return 'While bundling edge function';
+    }
+    return `While bundling function "${functionName}"`;
+};
+const getCoreStepLocation = function ({ coreStepName }) {
+    return `During ${coreStepName}`;
+};
+const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
+    const eventMessage = getEventMessage(event);
+    const pluginOrigin = getPluginOrigin(loadedFrom, origin);
+    return `${eventMessage} "${packageName}" ${pluginOrigin}`;
+};
+const getEventMessage = function (event) {
+    if (event === 'load') {
+        return `While loading`;
+    }
+    return `In "${event}" event in`;
+};
+const getApiLocation = function ({ endpoint, parameters }) {
+    return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`;
+};
+const LOCATIONS = {
+    buildCommand: getBuildCommandLocation,
+    functionsBundling: getFunctionsBundlingLocation,
+    coreStep: getCoreStepLocation,
+    buildFail: getBuildFailLocation,
+    api: getApiLocation,
+};

package/lib/error/parse/normalize.js

@@ -0,0 +1,24 @@
+// Ensure error is an `Error` instance.
+// If is an `Error` instance but is missing usual `Error` properties, we make
+// sure its static properties are preserved.
+export const normalizeError = function (error) {
+    if (Array.isArray(error)) {
+        return normalizeArray(error);
+    }
+    if (!(error instanceof Error)) {
+        return new Error(String(error));
+    }
+    if (typeof error.message !== 'string') {
+        error.message = String(error);
+    }
+    if (typeof error.stack !== 'string') {
+        Error.captureStackTrace(error, normalizeError);
+    }
+    return error;
+};
+// Some libraries throw arrays of Errors
+const normalizeArray = function (errorArray) {
+    const [error, ...errors] = errorArray.map(normalizeError);
+    error.errors = errors;
+    return error;
+};

package/lib/error/parse/parse.js

@@ -0,0 +1,67 @@
+import { serializeObject } from '../../log/serialize.js';
+import { getErrorInfo } from '../info.js';
+import { getTypeInfo } from '../type.js';
+import { getLocationInfo } from './location.js';
+import { normalizeError } from './normalize.js';
+import { getPluginInfo } from './plugin.js';
+import { getErrorProps } from './properties.js';
+import { getStackInfo } from './stack.js';
+// Add additional type-specific error information
+export const getFullErrorInfo = function ({ error, colors, debug }) {
+    const basicErrorInfo = parseErrorInfo(error);
+    const { message, stack, errorProps, errorInfo, errorInfo: { location = {}, plugin = {}, tsConfig }, severity, title, stackType, locationType, showErrorProps, rawStack, errorMetadata, } = basicErrorInfo;
+    const titleA = getTitle(title, errorInfo);
+    const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, severity, debug });
+    const pluginInfo = getPluginInfo(plugin, location);
+    const tsConfigInfo = getTsConfigInfo(tsConfig);
+    const locationInfo = getLocationInfo({ stack: stackA, location, locationType });
+    const errorPropsA = getErrorProps({ errorProps, showErrorProps, colors });
+    return {
+        ...basicErrorInfo,
+        title: titleA,
+        message: messageA,
+        tsConfigInfo,
+        pluginInfo,
+        locationInfo,
+        errorProps: errorPropsA,
+        errorMetadata,
+    };
+};
+// Serialize the `tsConfig` error information
+const getTsConfigInfo = function (tsConfig) {
+    if (tsConfig === undefined) {
+        return;
+    }
+    return serializeObject(tsConfig);
+};
+// Parse error instance into all the basic properties containing information
+export const parseErrorInfo = function (error) {
+    const { message, stack, ...errorProps } = normalizeError(error);
+    const [errorInfo, errorPropsA] = getErrorInfo(errorProps);
+    const { errorMetadata } = errorInfo;
+    const { type, severity, title, group, stackType, locationType, showErrorProps, showInBuildLog = true, rawStack, } = getTypeInfo(errorInfo);
+    const basicErrorInfo = {
+        message,
+        stack,
+        errorProps: errorPropsA,
+        errorInfo,
+        type,
+        severity,
+        title,
+        group,
+        stackType,
+        locationType,
+        showInBuildLog,
+        showErrorProps,
+        rawStack,
+        errorMetadata,
+    };
+    return basicErrorInfo;
+};
+// Retrieve title to print in logs
+const getTitle = function (title, errorInfo) {
+    if (typeof title !== 'function') {
+        return title;
+    }
+    return title(errorInfo);
+};

package/lib/error/parse/plugin.js

@@ -0,0 +1,55 @@
+// Retrieve plugin's package.json details to include in error messages.
+// Please note `pluginPackageJson` has been normalized by `normalize-package-data`.
+export const getPluginInfo = function ({ pluginPackageJson = {} }, { packageName, loadedFrom }) {
+    if (Object.keys(pluginPackageJson).length === 0) {
+        return;
+    }
+    return Object.entries(FIELDS)
+        .map(([name, getField]) => serializeField({ name, getField, pluginPackageJson, packageName, loadedFrom }))
+        .filter(Boolean)
+        .join('\n');
+};
+// Serialize a single package.json field
+const serializeField = function ({ name, getField, pluginPackageJson, packageName, loadedFrom }) {
+    const field = getField(pluginPackageJson, { packageName, loadedFrom });
+    if (field === undefined) {
+        return;
+    }
+    const nameA = `${name}:`.padEnd(NAME_PADDING);
+    return `${nameA}${field}`;
+};
+const NAME_PADDING = 16;
+const getPackage = function (pluginPackageJson, { packageName }) {
+    return packageName;
+};
+const getVersion = function ({ version }) {
+    if (version === '') {
+        return;
+    }
+    return version;
+};
+export const getHomepage = function (pluginPackageJson = {}, { loadedFrom } = {}) {
+    return (getRepository(pluginPackageJson) ||
+        getNpmLink(pluginPackageJson, { loadedFrom }) ||
+        getIssuesLink(pluginPackageJson));
+};
+const getRepository = function ({ repository: { url } = {} }) {
+    return url;
+};
+const getNpmLink = function ({ name }, { loadedFrom }) {
+    if (!name || loadedFrom === 'local') {
+        return;
+    }
+    return `https://www.npmjs.com/package/${name}`;
+};
+const getIssuesLink = function ({ bugs: { url } = {} }) {
+    return url;
+};
+// List of package.json to serialize
+const FIELDS = {
+    Package: getPackage,
+    Version: getVersion,
+    Repository: getRepository,
+    'npm link': getNpmLink,
+    'Report issues': getIssuesLink,
+};

package/lib/error/parse/properties.js

@@ -0,0 +1,16 @@
+import { inspect } from 'util';
+import { omit } from '../../utils/omit.js';
+// In uncaught exceptions, print error static properties
+export const getErrorProps = function ({ errorProps, showErrorProps, colors }) {
+    if (!showErrorProps) {
+        return;
+    }
+    const errorPropsA = omit(errorProps, CLEANED_ERROR_PROPS);
+    if (Object.keys(errorPropsA).length === 0) {
+        return;
+    }
+    return inspect(errorPropsA, { colors, depth: INSPECT_MAX_DEPTH });
+};
+const INSPECT_MAX_DEPTH = 5;
+// Remove error static properties that should not be logged
+const CLEANED_ERROR_PROPS = ['requireStack'];

package/lib/error/parse/serialize_log.js

@@ -0,0 +1,34 @@
+import { THEME } from '../../log/theme.js';
+// Serialize an error object into a title|body string to print in logs
+export const serializeLogError = function ({ fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps }, }) {
+    const body = getBody({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity });
+    return { title, body };
+};
+const getBody = function ({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity }) {
+    if (severity === 'none') {
+        return message;
+    }
+    return Object.entries({
+        message,
+        tsConfigInfo,
+        pluginInfo,
+        locationInfo,
+        errorProps,
+    })
+        .filter(blockHasValue)
+        .map(serializeBlock)
+        .join('\n\n');
+};
+const blockHasValue = function ([, value]) {
+    return value !== undefined;
+};
+const serializeBlock = function ([key, value]) {
+    return `${THEME.errorSubHeader(LOG_BLOCK_NAMES[key])}\n${value}`;
+};
+const LOG_BLOCK_NAMES = {
+    message: 'Error message',
+    pluginInfo: 'Plugin details',
+    locationInfo: 'Error location',
+    tsConfigInfo: 'TypeScript configuration',
+    errorProps: 'Error properties',
+};

package/lib/error/parse/serialize_status.js

@@ -0,0 +1,18 @@
+// Serialize an error object to `statuses` properties
+export const serializeErrorStatus = function ({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }) {
+    const text = getText({ locationInfo, errorProps });
+    return { state, title, summary: message, text, extraData: errorMetadata };
+};
+const getText = function ({ locationInfo, errorProps }) {
+    const parts = [locationInfo, getErrorProps(errorProps)].filter(Boolean);
+    if (parts.length === 0) {
+        return;
+    }
+    return parts.join('\n\n');
+};
+const getErrorProps = function (errorProps) {
+    if (errorProps === undefined) {
+        return;
+    }
+    return `Error properties:\n${errorProps}`;
+};

package/lib/error/parse/stack.js

@@ -0,0 +1,34 @@
+import { cleanStacks } from './clean_stack.js';
+// Retrieve the stack trace
+export const getStackInfo = function ({ message, stack, stackType, rawStack, severity, debug }) {
+    const { message: messageA, stack: stackA } = splitStackInfo({ message, stack, stackType });
+    const messageB = severity === 'none' ? messageA.replace(SUCCESS_ERROR_NAME, '') : messageA;
+    const stackB = cleanStacks({ stack: stackA, rawStack, debug });
+    return { message: messageB, stack: stackB };
+};
+const splitStackInfo = function ({ message, stack, stackType }) {
+    // Some errors should not show any stack trace
+    if (stackType === 'none') {
+        return { message };
+    }
+    // Some errors have their stack trace inside `error.message` instead of
+    // `error.stack` due to IPC
+    if (stackType === 'message') {
+        return splitStack(message);
+    }
+    return splitStack(stack);
+};
+const splitStack = function (string) {
+    const lines = string.split('\n');
+    const stackIndex = lines.findIndex(isStackTrace);
+    if (stackIndex === -1) {
+        return { message: string };
+    }
+    const messageA = lines.slice(0, stackIndex).join('\n');
+    const stackA = lines.slice(stackIndex).join('\n');
+    return { message: messageA, stack: stackA };
+};
+const isStackTrace = function (line) {
+    return line.trim().startsWith('at ');
+};
+const SUCCESS_ERROR_NAME = 'Error: ';

package/lib/error/report.js

@@ -0,0 +1,29 @@
+import { isNetlifyMaintainedPlugin } from '../plugins/internal.js';
+import { closeClient, formatTags, normalizeTagName, startClient, validateStatsDOptions, } from '../report/statsd.js';
+import { getErrorInfo } from './info.js';
+const TOP_PARENT_TAG = 'run_netlify_build';
+/**
+ * Record error rates of the build phase for monitoring.
+ * Sends to statsd daemon.
+ */
+export const reportError = async function (error, statsdOpts, framework) {
+    if (!validateStatsDOptions(statsdOpts)) {
+        return;
+    }
+    const [errorInfo] = getErrorInfo(error);
+    const pluginName = errorInfo.plugin ? normalizeTagName(errorInfo.plugin.packageName) : null;
+    // only send tracking if it is a known plugin
+    if (pluginName && !isNetlifyMaintainedPlugin(pluginName)) {
+        return;
+    }
+    const parent = pluginName ? pluginName : TOP_PARENT_TAG;
+    const stage = pluginName ? errorInfo.location?.event : errorInfo.stage;
+    const statsDTags = { stage: stage ?? 'system', parent };
+    // Do not add a framework tag if empty string or null/undefined
+    if (framework) {
+        statsDTags.framework = framework;
+    }
+    const client = await startClient(statsdOpts);
+    client.increment('buildbot.build.stage.error', 1, formatTags(statsDTags));
+    await closeClient(client);
+};

package/lib/error/type.js

@@ -0,0 +1,177 @@
+// Retrieve error-type specific information
+export const getTypeInfo = function ({ type }) {
+    const typeA = TYPES[type] === undefined ? DEFAULT_TYPE : type;
+    return { type: typeA, ...TYPES[typeA] };
+};
+// List of error types, and their related properties
+// Related to build error logs:
+//  - `showInBuildLog`: `true` when we want this error to show in build logs (defaults to true)
+//  - `title`: main title shown in build error logs and in the UI (statuses)
+//  - `locationType`: retrieve a human-friendly location of the error, printed
+//    in build error logs
+//  - `showErrorProps`: `true` when the `Error` instance static properties
+//    should be printed in build error logs. Only useful when the `Error`
+//    instance was not created by us.
+//  - `rawStack`: `true` when the stack trace should be cleaned up
+//  - `stackType`: how the stack trace should appear in build error logs:
+//      - `none`: not printed
+//      - `stack`: printed as is
+//      - `message`: printed as is, but taken from `error.message`.
+//        Used when `error.stack` is not being correct due to the error being
+//        passed between different processes.
+//  - `severity`: error severity (also used by Bugsnag):
+//      - `success`: build success
+//      - `none`: not an error, e.g. build cancellation
+//      - `info`: user error
+//      - `warning`: community plugin error
+//      - `error`: system error, including core plugin error
+// Related to Bugsnag:
+//  - `group`: main title shown in Bugsnag. Also used to group errors together
+//    in Bugsnag, combined with `error.message`.
+//    Defaults to `title`.
+// New error types should be added to Bugsnag since we use it for automated
+// monitoring (through its Slack integration). The steps in Bugsnag are:
+//  - Create a new bookmark. Try to re-use the search filter of an existing
+//    bookmark with a similar error type, but only changing the `errorClass`.
+//    Make sure to check the box "Share with my team".
+//  - Add the `errorClass` to the search filter of either the "All warnings" or
+//    "All errors" bookmark depending on whether we should get notified on Slack
+//    for new errors of that type. You must use the bookmark menu action "Update
+//    with current filters"
+const TYPES = {
+    // Plugin called `utils.build.cancelBuild()`
+    cancelBuild: {
+        title: ({ location: { packageName } }) => `Build canceled by ${packageName}`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'none',
+    },
+    // User configuration error (`@netlify/config`, wrong Node.js version)
+    resolveConfig: {
+        title: 'Configuration error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // Error while installing user packages (missing plugins, local plugins or functions dependencies)
+    dependencies: {
+        title: 'Dependencies installation error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // User misconfigured a plugin
+    pluginInput: {
+        title: ({ location: { packageName, input } }) => `Plugin "${packageName}" invalid input "${input}"`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // User package.json sets an unsupported plugin version
+    pluginUnsupportedVersion: {
+        title: 'Unsupported plugin version detected',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // `build.command` non-0 exit code
+    buildCommand: {
+        title: '"build.command" failed',
+        group: ({ location: { buildCommand } }) => buildCommand,
+        stackType: 'message',
+        locationType: 'buildCommand',
+        severity: 'info',
+    },
+    // User error during Functions bundling
+    functionsBundling: {
+        title: ({ location: { functionName, functionType } }) => {
+            if (functionType === 'edge') {
+                return 'Bundling of edge function failed';
+            }
+            return `Bundling of function "${functionName}" failed`;
+        },
+        group: ({ location: { functionType = 'serverless' } }) => `Bundling of ${functionType} function failed`,
+        stackType: 'none',
+        locationType: 'functionsBundling',
+        severity: 'info',
+    },
+    // Plugin called `utils.build.failBuild()`
+    failBuild: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // Plugin called `utils.build.failPlugin()`
+    failPlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // Plugin has an invalid shape
+    pluginValidation: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Plugin threw an uncaught exception
+    pluginInternal: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Bug while orchestrating child processes
+    ipc: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Core plugin internal error
+    corePlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'error',
+    },
+    // Core step internal error
+    coreStep: {
+        title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'coreStep',
+        severity: 'error',
+    },
+    // Request error when `@netlify/build` was calling Netlify API
+    api: {
+        title: ({ location: { endpoint } }) => `API error on "${endpoint}"`,
+        stackType: 'message',
+        showErrorProps: true,
+        locationType: 'api',
+        severity: 'error',
+    },
+    // `@netlify/build` threw an uncaught exception
+    exception: {
+        title: 'Core internal error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+    // Errors related with the telemetry output
+    telemetry: {
+        showInBuildLog: false,
+        title: 'Telemetry error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+};
+// When no error type matches, it's an uncaught exception, i.e. a bug
+const DEFAULT_TYPE = 'exception';

package/lib/install/functions.js

@@ -0,0 +1,20 @@
+import { dirname } from 'path';
+import readdirp from 'readdirp';
+import { logInstallFunctionDependencies } from '../log/messages/install.js';
+import { installDependencies } from './main.js';
+// Install dependencies of Netlify Functions
+export const installFunctionDependencies = async function (functionsSrc, isLocal) {
+    const packagePaths = await getPackagePaths(functionsSrc);
+    if (packagePaths.length === 0) {
+        return;
+    }
+    logInstallFunctionDependencies();
+    const packageRoots = packagePaths.map(getPackageRoot);
+    await Promise.all(packageRoots.map((packageRoot) => installDependencies({ packageRoot, isLocal })));
+};
+const getPackagePaths = function (functionsSrc) {
+    return readdirp.promise(functionsSrc, { depth: 1, fileFilter: 'package.json' });
+};
+const getPackageRoot = function ({ fullPath }) {
+    return dirname(fullPath);
+};